From 707f04402599d590535ed5ea08bc7dba01eb5ef0 Mon Sep 17 00:00:00 2001
From: ANUSKA KUNDU <56089413+AnuskaK10@users.noreply.github.com>
Date: Tue, 25 Aug 2020 13:32:06 +0530
Subject: [PATCH 1/2] Add files via upload

---
 Bubble.class    | Bin 0 -> 1076 bytes
 Bubble.java     |  46 +++++++++++++++++++++++++++++++
 Insertion.class | Bin 0 -> 1034 bytes
 Insertion.java  |  31 +++++++++++++++++++++
 Merge.class     | Bin 0 -> 1449 bytes
 Merge.java      |  70 ++++++++++++++++++++++++++++++++++++++++++++++++
 Selection.class | Bin 0 -> 1061 bytes
 Selection.java  |  36 +++++++++++++++++++++++++
 8 files changed, 183 insertions(+)
 create mode 100644 Bubble.class
 create mode 100644 Bubble.java
 create mode 100644 Insertion.class
 create mode 100644 Insertion.java
 create mode 100644 Merge.class
 create mode 100644 Merge.java
 create mode 100644 Selection.class
 create mode 100644 Selection.java

diff --git a/Bubble.class b/Bubble.class
new file mode 100644
index 0000000000000000000000000000000000000000..9e936b253fb0c748fa12dd5aa6af8e520ecf15bf
GIT binary patch
literal 1076
zcmZuw-A)rh7(LVdqs#Imut<UOCt{({qGCnBnxHW>0ZUSYL2lT#8&Yhyq_jrvc?vIy
z3D<H_5-~i07skghCcXeM;+d^UAz_o9`R2@-?>pz4-EV)toCBD{f{8YS4GftG$ay%3
z5saEpF(!vQ5+0Y>-4;xkxQB=wCJjsp=t~8!P)!Obk;x4K^?5n(3UsU%Joi<tlyxhw
zootbanXP3R?3XK50WGqXlI*rj)ychEbM|}^1sI4jN69I80=<!~)m`Vk6E8a6PCQes
z6uh0q$qfV3RLF#xa;=hcUlwHc)@46?O!6(Xql3a4kiacJNv&Ea#xps`^W2Jo84EGQ
zC3DuoeLS$xg>DNEF(+VUsL{=jIF*WXVBnF31Rh(M#}k3hrl53o*UiyOU@IlieS_3%
z?99P_)h&@No!Jdvg>pRQ?bWKZ<~pTCfxgI%8?sY|=YFWBJl12MSx_n07&jBGvpda1
z-M&obzXCJIo+K5efd7TAcb50!Gk60LUJvg(!0$pn3STxAw8SXPS#Z{-P9Z)sV2?TK
zJ{VxcUNV-{pU_}%exoF`=y^g{o(|f&nm@vdk__AWU|z;CxfzZ{!|HbI6Z#n@)M(gW
zrsZg>X*Ho8D&qL^yRChMevIH@fUCMJ9`K7NsSYfqpoL?QSSxk5(L+0;lrl?Xp2D6{
z+A{Z6(2F(nVV&F!44{Xn7olHrX&A5#^wOc=dljK=A~DUll(w$Xc<wgSHC+Fo44ny`
zGXyqIp{$-k-8_MI3Vm(54kH=<YA&dBZEKz85xPREtw}t6sL|E$Xh^N2<pjYlvyN7u
z7E;fT&_hU4V|7?Q^H<Y<!oR5@x*w*)5lR`Q|1tii<MckpPj~`LT)jX9X-wfQ=WWdR
fzDJ>6@`!FA<a_ED4f_|c|DaP`_`U}GRuBFI)*Q!q

literal 0
HcmV?d00001

diff --git a/Bubble.java b/Bubble.java
new file mode 100644
index 0000000..d5b4a04
--- /dev/null
+++ b/Bubble.java
@@ -0,0 +1,46 @@
+import java.util.Scanner;
+class Bubble
+{
+    void bubblesort(int arr[])
+    {
+        int i,j,temp;
+        boolean swapped=false;
+        int n=arr.length;
+        for(i=0;i<n-1;i++)
+        {
+            for(j=0;j<n-i-1;j++)
+            {
+                swapped=false;
+                if(arr[j]>arr[j+1])
+                {
+                    temp=arr[j];
+                    arr[j]=arr[j+1];
+                    arr[j+1]=temp;
+                    swapped=true;
+                }
+            }
+            if(swapped==false)
+            {
+                break;
+            }
+        }
+    }
+    public static void main(String args[])
+    {
+        Bubble b=new Bubble();
+        Scanner sc=new Scanner(System.in);
+        int arr[]=new int[10];
+        for(int i=0;i<10;i++)
+        {
+            arr[i]=sc.nextInt();
+        }
+        b.bubblesort(arr);
+        System.out.println("Sorted array");
+        for(int i=0;i<arr.length;i++)
+        {
+            System.out.print(arr[i]);
+        }
+
+    }
+
+}
\ No newline at end of file
diff --git a/Insertion.class b/Insertion.class
new file mode 100644
index 0000000000000000000000000000000000000000..3542d7ed4cca340598a0fcd7d27008c60bc8bc8b
GIT binary patch
literal 1034
zcmaJ<&rcIk5dL2Kw%e{tS%C$C7Ap#DS!flo@<WMAV$uXzV-3lMiwoV5g?8I4TNCd5
z2Ohl{6V7@li5L=Z#(%-H|AR5XI<KGvAs%+#?94Ya-#71l{q^w(zzh}?bYe)xbp;U&
z36n|S28QFfso)kyWQ;0^V<?U>aT>y8g&7xVQ^o{C?7ruF;UYuS$gVQ*rCQl#=v?-E
zccoEXcY_zsdW9l<rxt_^lCf44xQ<fjY-~Su>VMKz$MYF_jkV=1=arMMIR0k76b7EZ
zxsY9zF)1TQL>ZJ)tr2XvPdw2yS@d_@AoOZ}PE@JTaFrqPH>#osx{SPv+qlD^mWYE}
z&NxBf?8=x@F^w69zJDh^Zg`cl8!)hpin}NXb5F%A=2Xm!3hk`ITHkUvNLcqJ#2F%M
z#dGM=?oQ}dX<4-f)#xW$y;}Ym2@OfE>r@x0SG)cBFoRqdpbBkCH!fQe-Gx)HyMCEr
z@-o1Mnp2rHFl7|8|4GNg+R0Tg^cWX`)Ie%;Lx!GECp|47N*`SY7`n(y)5++R#t*>W
zlS3NG#@a!Vplc#uKwpDX9C&0NJ>ZM!)LYD%>0E)QdAT6z(i@~qUCQbF9lFWkFU6m=
zC$;ul-`oE>xAvlJzx73oiL}RzLm^)xPBHT0#4tev6%3;T6G&o;n9ft~Ara^$qy~Nr
ziLqlO8B6~lR04gtc1rLw5tIm3(d18x9o0rHn`?uXEor7@$6}T(YYEGaYtJoPi)o6r
zOhOJ3u@4YknKYZ=A0TzbnvkOfu5;2iLV-iX36SVgnz&->JlBNUL`M_JJx*G_ooN{*
zE}&%@#MC5K)5L2Q{lt9$MWo=;xs9Q=jy^<MSb`*@U&a8FF-WWai7^tAq9zffe*>ys
B)7=07

literal 0
HcmV?d00001

diff --git a/Insertion.java b/Insertion.java
new file mode 100644
index 0000000..e5154bb
--- /dev/null
+++ b/Insertion.java
@@ -0,0 +1,31 @@
+class Insertion
+{
+    void sort(int arr[])
+    {
+        int n=arr.length;
+        for(int i=1;i<n;i++)
+        {
+            int key=arr[i];
+            int j=i-1;
+            while(j>=0 && arr[j]>key)
+            {
+                //move elements greater than key to one space ahead to make space for key
+                arr[j+1]=arr[j];
+                j--;
+            }
+            arr[j+1]=key;
+        }
+    }
+    public static void main(String args[])
+    {
+        int arr[]={38,27,43,3,9,82,10};
+        int l=arr.length;
+        Insertion m=new Insertion();
+        m.sort(arr);
+        System.out.println("Sorted array");
+        for(int i=0;i<l;i++)
+        {
+            System.out.print(" "+arr[i]);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Merge.class b/Merge.class
new file mode 100644
index 0000000000000000000000000000000000000000..97c06abca09aa856e2ed20b0f21e78d878c561d2
GIT binary patch
literal 1449
zcmaJ>OK%%h7(LgXw<pasbdtCom!zeMAB|1hboxk>0xh73qy~&Cxmn;zJPHne$+eNX
zVU;ZsD|T!w0b+$<;Yze>B_zb-FYpU!{{ai!bH{}wG-71k@6J8vdz|mP<KO@O@ezPU
zT({t0)`EglayhNz6=`QpoWY!dc?)S|bYv}<m^F}-_N-hM<dT<gLC32C+O=A<)?E>Z
zr!%(&lpC#TC@{WOYlgRajm@z0L9kipiP{J|+q6b{W0jBOj+MH>*2n8XJEE`x9p?nh
zh<LZv=?dr(If~l|YE6O3^v2pw@JUdp2hHt5soSYFx0f=vb(|NlO08aJD}1Xa(^=~>
zU0!l+9L0o<<2Yf%#Ux9KFdY|cHsYdyU1GAZIump{!95+mjZ3&JF!kR=Z}e*QYS<AF
zGd8Z^s$7<AT*I=B73tyZc@#Hy!YwL@ZLA8sbV$($*rj`SyJ3SpZ1w2ljwIGvg?Fj1
zOO;{JSYntc{J~@Ps4Yo#HpfjL)*Fr}Xt%>=Rbb&T!V5mnWip|cUd{XuY;;?r2?!iZ
zzer>NHL49Wyjc#f9cUq^0gB-+MJs64?0tyuxnUr#T68D@j*ELz#aB>a^W?XbS5+#$
z;VP-BZ@R`q>#F6NToZ9$bye5s<5<#i)tu+5m3(nm72gb>#(mAzT(ghKWWv>QDW&3S
z64VI(Nk8JAuaCShkC^9Vki4Yl`<TeNdh{N}!?=8vh>WnSGsrI^Uw1z*0-lVbMZf`%
zCsJ-KlDosJDMgRLpi~n{BygH<dD=yc^J*Q%JGAc+y+e<W*pwco@hO?R?BQoPiO<>N
zFX;6pKi{u0hi@^D?~uU&IXuQ${DcMkiUOvX=?<(RJlHy>btDBJ_E&JrA22m!S^F?f
z=wB>3WQqGR`u^jWNvPA)jLy$&G%|e1k*Pe%dZ|9<y_8a|sC8e-ax}^Sv24y&lu9bv
z@r0ZBUQdp*AHaF~FX9L;Qn62km#FAUq#+KGVXM683dyVV^YdhFM}KIQ<IY^MtT-o%
zW!1?Q%bHd!>yBA08_xU1vZFaxaV_^~`2m#jeW<q<a&b?ovXCF3P3Qv{abIy2ua7f4
zcmR_mYa%g#&5H8_j16#Pfbm_0ga2c%<T=&@{u!jP%%-p40<QDzHQdDOSjP?2Xj^zQ
dDt`*GA>M|n<D?t`C&3x~g?V=FWd@01<{4rR3?u*m

literal 0
HcmV?d00001

diff --git a/Merge.java b/Merge.java
new file mode 100644
index 0000000..9eeb144
--- /dev/null
+++ b/Merge.java
@@ -0,0 +1,70 @@
+class Merge
+{
+    void merge(int arr[],int l,int m,int r)
+    {
+      int i,j,k;
+      int n1=(m-l)+1;int n2=r-m;
+      //making temporary arrays
+      int L[]=new int[n1];
+      int R[]=new int[n2];
+      //copying data to temporary arrays
+      for(i=0;i<n1;i++)
+      {
+        L[i]=arr[l+i];
+      }
+      for(j=0;j<n2;j++)
+      {
+          R[j]=arr[m+1+j];
+      }
+      i=0;j=0;k=l;
+      while(i<n1 && j<n2)
+      {
+          if(L[i]<R[j])
+          {
+              arr[k]=L[i];
+              i++;
+          }
+          else
+          {
+              arr[k]=R[j];
+              j++;
+          }
+          k++;
+      }
+      //remaining elements
+      while(i<n1)
+      {
+          arr[k]=L[i];
+          i++;
+          k++;
+      }
+      while(j<n2)
+      {
+          arr[k]=R[j];
+          j++;
+          k++;
+      }
+    }
+    void mergesort(int arr[],int l,int r)
+    {
+       if(l<r)
+       {
+           int m=(l+(r-1))/2;
+           mergesort(arr,l,m);
+           mergesort(arr,m+1,r);
+           merge(arr,l,m,r);
+       }
+    }
+    public static void main(String args[]) 
+    {
+        int arr[]={38,27,43,3,9,82,10};
+        int l=arr.length;
+        Merge m=new Merge();
+        m.mergesort(arr,0,l-1);
+        System.out.println("Sorted array");
+        for(int i=0;i<l;i++)
+        {
+            System.out.print(" "+arr[i]);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Selection.class b/Selection.class
new file mode 100644
index 0000000000000000000000000000000000000000..5cec6e91858bc11fd811ba382f934ba0ef28e9c0
GIT binary patch
literal 1061
zcmaJ=T~8BH5Iwiu+uN>7S%C$FE>scNveGI-{Q!wdqBcR+SVOYm#f5IjLcdbBCcN`Y
zNQ}?=P!cgDy!sdX1O5d`Q0EquAjF5AJDE8%bI#nmUw?i+05FYN6`dFo7*-L%kTmH8
zuH!}=BPwoURA5X+97A!8%hQr3Bh7?N+XA;3Vsk+?2<I81R%V$&S*VqKhR(&H>Mu1b
ztA68+w_2u1$Ch9A*TSGyE!G+#1GiQRvY?|FdTX06z4|Fmsdzz^q1Rej-0<Fcxw2PX
z&lST)P+gzREDKBuWQj3@TC6o2YyPu9c25@nbkE8v4LYteB>qM<^uQ3vX}FC$44UNN
zm(pIN;cW{{X}F7NhQ5C%K5Yi&lHXupX$>>TOLI@deLT?cP*&(?70&7g>0{`=gg8TF
zrEm^i+};ZP3T>^{q#ENyYf#I*BB3G4^}Wh0^=h|2A7&7B2`bZ;4C}Hb(WQ9xx?e3Z
zOkM`KP;)Ai2Bxe+=0E9pSUb52h92u8kQ(qdH>Bw;b<!IHqV&;afT4>#lTJn_pV$NY
zNDgTv8*2w;g06{t34ITR;=l|0;8AqmOev*Z%$s?|RNm&f!Be~Fw+)`P4JEq^Veq`N
z!`X*l-(?`r$=YVtu}y<JJ5h=s%4w1Iv?*xhbD}25OAt{N1LTb&i46HUnm<FxIb!pK
zFwfD4UaIH@KL%&)7)i!@j=+CVB0*pODdj_=%n4Z5#TV6$>SK<p=!1^Sb=z@cF~=2p
z!g1sJYsb}Ny6P;Fw0%U}Jw%r#?G}_z;9ap6L^Q7$3Mm|=z&_#xNOY+!T#?#Z&|2td
zA-SWFtZ!$s#)u0@h=oDeNYRrv>7@?gF@{l~-`b~h6C-UYeTe+R0=U36fdM8kNXtLM
LI0;EnlL*Y;@2J@#

literal 0
HcmV?d00001

diff --git a/Selection.java b/Selection.java
new file mode 100644
index 0000000..77ce406
--- /dev/null
+++ b/Selection.java
@@ -0,0 +1,36 @@
+class Selection
+{
+    void selectionSort(int arr[])
+    {
+        int n=arr.length;
+        //move the boundary of unsorted array
+        for(int i=0;i<n-1;i++)
+        {
+            int min_index=i;
+            for(int j=i+1;j<n;j++)
+            {
+                if(arr[j]<arr[min_index])
+                    {
+                        min_index=j;
+                    }
+                }
+                //System.out.println(min_index+" "+arr[i]);
+                int temp=arr[min_index];
+                arr[min_index]=arr[i];
+                arr[i]=temp;
+           
+        }
+    }
+    public static void main(String args[]) 
+    {
+        int arr[]={38,27,43,3,9,82,10};
+        int l=arr.length;
+        Selection m=new Selection();
+        m.selectionSort(arr);
+        System.out.println("Sorted array");
+        for(int i=0;i<l;i++)
+        {
+            System.out.print(" "+arr[i]);
+        }
+    }
+}
\ No newline at end of file

From ecd7b12d1c6e30c749ecdc8ef0f3a45db2538835 Mon Sep 17 00:00:00 2001
From: ANUSKA KUNDU <56089413+AnuskaK10@users.noreply.github.com>
Date: Fri, 25 Sep 2020 11:42:03 +0530
Subject: [PATCH 2/2] Common Divide nd Conquer Algorithms in Java

---
 DivideNConquer/Closest.class     | Bin 0 -> 1281 bytes
 DivideNConquer/Closest.java      |  39 +++++++
 DivideNConquer/Duplicates.class  | Bin 0 -> 1976 bytes
 DivideNConquer/Duplicates.java   | 103 +++++++++++++++++++
 DivideNConquer/Dutch.class       | Bin 0 -> 1961 bytes
 DivideNConquer/Dutch.java        | 104 +++++++++++++++++++
 DivideNConquer/Histo.class       | Bin 0 -> 946 bytes
 DivideNConquer/Histo.java        |  27 +++++
 DivideNConquer/Hoare.class       | Bin 0 -> 1752 bytes
 DivideNConquer/Hoare.java        |  62 +++++++++++
 DivideNConquer/Matrix.java       | 170 +++++++++++++++++++++++++++++++
 DivideNConquer/MaxMin$Pair.class | Bin 0 -> 273 bytes
 DivideNConquer/MaxMin.class      | Bin 0 -> 1178 bytes
 DivideNConquer/MaxMin.java       |  64 ++++++++++++
 DivideNConquer/Missing.class     | Bin 0 -> 1720 bytes
 DivideNConquer/Missing.java      |  88 ++++++++++++++++
 DivideNConquer/NumeroUno.class   | Bin 0 -> 1672 bytes
 DivideNConquer/NumeroUno.java    | 103 +++++++++++++++++++
 DivideNConquer/Occurence.class   | Bin 0 -> 1888 bytes
 DivideNConquer/Occurence.java    |  94 +++++++++++++++++
 DivideNConquer/Pair.class        | Bin 0 -> 367 bytes
 DivideNConquer/Peak.class        | Bin 0 -> 909 bytes
 DivideNConquer/Peak.java         |  25 +++++
 DivideNConquer/PowerOfN.class    | Bin 0 -> 963 bytes
 DivideNConquer/PowerOfN.java     |  27 +++++
 DivideNConquer/Prefix.class      | Bin 0 -> 1838 bytes
 DivideNConquer/Prefix.java       |  55 ++++++++++
 DivideNConquer/SRoot.class       | Bin 0 -> 757 bytes
 DivideNConquer/SRoot.java        |  40 ++++++++
 DivideNConquer/SumSub.class      | Bin 0 -> 1216 bytes
 DivideNConquer/SumSub.java       |  44 ++++++++
 DivideNConquer/input.txt         |   2 +
 DivideNConquer/num.txt           |   2 +
 33 files changed, 1049 insertions(+)
 create mode 100644 DivideNConquer/Closest.class
 create mode 100644 DivideNConquer/Closest.java
 create mode 100644 DivideNConquer/Duplicates.class
 create mode 100644 DivideNConquer/Duplicates.java
 create mode 100644 DivideNConquer/Dutch.class
 create mode 100644 DivideNConquer/Dutch.java
 create mode 100644 DivideNConquer/Histo.class
 create mode 100644 DivideNConquer/Histo.java
 create mode 100644 DivideNConquer/Hoare.class
 create mode 100644 DivideNConquer/Hoare.java
 create mode 100644 DivideNConquer/Matrix.java
 create mode 100644 DivideNConquer/MaxMin$Pair.class
 create mode 100644 DivideNConquer/MaxMin.class
 create mode 100644 DivideNConquer/MaxMin.java
 create mode 100644 DivideNConquer/Missing.class
 create mode 100644 DivideNConquer/Missing.java
 create mode 100644 DivideNConquer/NumeroUno.class
 create mode 100644 DivideNConquer/NumeroUno.java
 create mode 100644 DivideNConquer/Occurence.class
 create mode 100644 DivideNConquer/Occurence.java
 create mode 100644 DivideNConquer/Pair.class
 create mode 100644 DivideNConquer/Peak.class
 create mode 100644 DivideNConquer/Peak.java
 create mode 100644 DivideNConquer/PowerOfN.class
 create mode 100644 DivideNConquer/PowerOfN.java
 create mode 100644 DivideNConquer/Prefix.class
 create mode 100644 DivideNConquer/Prefix.java
 create mode 100644 DivideNConquer/SRoot.class
 create mode 100644 DivideNConquer/SRoot.java
 create mode 100644 DivideNConquer/SumSub.class
 create mode 100644 DivideNConquer/SumSub.java
 create mode 100644 DivideNConquer/input.txt
 create mode 100644 DivideNConquer/num.txt

diff --git a/DivideNConquer/Closest.class b/DivideNConquer/Closest.class
new file mode 100644
index 0000000000000000000000000000000000000000..0cad6a6011a2a83c230259a8933973ef49feea29
GIT binary patch
literal 1281
zcmaJ>-*4Mg7(KV~^>rMlxy|Nv(4-3++Z>N23`Y3THo#U*MCul#PD4>&>L#Z3NSu(k
zAl?VO@jq-YNC+XpLstPB@4WHvOladcjVQ2*NIv)EyPv;%zH>kM_a{F;0&o@Y*(hMy
z#u-#>%;Tk$olV)fEMCTWg$p(mmMvUNS1*NX3cig?ctzo|LQTM2jp8V23S_+M9RcI|
zuonsxHljGZwLjPi$G3x>J|k8)=y!Y3BoR>FR;$&jwgmE<Nznb|W-yv1scwHb3DX?O
zoN7y<&XR*5iUm%2TN`(S&w_eCh<EFo$vBF4SJETx&EfvI8{UZ0W1Q<p6>4d!1C0fR
zR~=lzYYtArb?`c_I#|SMg*O~D@TS1xf2&^GkNUlEEa0tEZxDCG%1)Sk9)@vcrmr#z
zqH$&Tab+}&;$*Vs;4QqJ!aELDu&TgF6YsLsnH&Lqd`f%gZrEjyb6d1v{y2U!NcPz7
z<kK-X4R5`=PFDwM@6tQ+>mNlnznCQ9fC<BWX1hn$M8o=r^d+G?VK7+X?F6Gy821D&
zd(ScNnb53rzF6{F)&JSHlHt(}2%PkuO=N)+)4u*Kh<=Pxd40CzK2OjcR5*VHjwfL7
z;q^hFNLJ=5xJv&a#E&FAfoM*H8CdD%lBcOZKypff&cek)Gt)4Z8q$@e2YBC=#&*MW
zP4c>Hy0SNgJ>Qiz-!*H!zscVA*N2$<reWMO#kWuYxF?CfxkmW`OxI|Zzi08e>G3{n
zaz(8cF-yHRO32|F*AMvr798A09v`u*Q_MU8`2@BQ;!otnV_bO*Y4KH#<4pT~mdY}*
zm09&4tu2+dWxwfX%EtB~*ojY4N}0?w%#v33QSi&MSGK0x)aJ@V7!Bnr*G!4!TE|*z
z)CC%pDwnh?N5fpII>Y17Qh<jS`B5lgjb7it@>FjT;wghl;RTB3j}@}aTbjxJj&d`M
zeWi=P+MSHfw>yR|v^!Ee?T)EcyQB1cyJKnH?r75>C~Xrhy+F+BEYX&PoX!y)y-3XK
zB5_`yCKfD$&JY%~+1|Kx2)XtX%wM274`CIv2e3;A$Q{5rK>m0viqq*ihh2Wi`Z$j-
Mae<0UR62+9U*g;L_y7O^

literal 0
HcmV?d00001

diff --git a/DivideNConquer/Closest.java b/DivideNConquer/Closest.java
new file mode 100644
index 0000000..8656dbc
--- /dev/null
+++ b/DivideNConquer/Closest.java
@@ -0,0 +1,39 @@
+//Considering the index is the x coordinate
+import java.io.*;
+class Closest
+{
+    static int calcdist(int arr[],int l,int r)
+    {
+        int min = 9999;  
+        int dist=0;
+        for (int i = l; i < r; ++i)  
+            for (int j = i+1; j < r; ++j)  
+            dist=(int)Math.sqrt(((j-i)*(j-i))+((arr[i]-arr[j])*(arr[i]-arr[j])));
+            if (dist < min)  
+                min = dist;  
+        return min;  
+    }
+    static int closest(int arr[])
+    {
+        int l=0;
+        int r=arr.length;
+        int mid=(l+r)/2;
+        int dl=calcdist(arr,0,mid+1);
+        int dr=calcdist(arr,mid+1,r);
+        int d3=0;//for calculating distance of split array containing 7 mid points
+        if(r>=7)
+        {
+            d3=calcdist(arr,mid-2,mid+5);
+        }
+        int d=Math.min(dl,dr);
+        int val=Math.min(d,d3);
+        return val;
+    }
+    public static void main(String args[])
+    {
+     
+     int arr[]={13,15,12,7,14,16,1,10,17,9,2,11,23,18,24,5,0,6};
+     int c=closest(arr);
+     System.out.println("Distance between closest pair of points="+c);
+    }
+}
\ No newline at end of file
diff --git a/DivideNConquer/Duplicates.class b/DivideNConquer/Duplicates.class
new file mode 100644
index 0000000000000000000000000000000000000000..ac0b1125f57e4db4b06cca675c3eca8b079432a4
GIT binary patch
literal 1976
zcmaJ>OK%%h6#lL~<FTDdGLvNbvQ5+U5kC?qZBwVvCeSBMaqB`#z!a%*>}hdv#+GBF
zLbq8Uv4Ac>LM#fUQdwlvBBd2YT~vYvmEd2nV2^|<O8D-zRj0JVmcMiEIp?1H-E;2o
zFaP{-AHW1ohcSTRF!~XfkT8%8A%&4JG>l41T54m`Hf~^d7-0+tu}8|i5+)?<3nPO`
z1N(z`(ZEXv4hRGemc4RgTEHJq%n4{mswG#TH(U1H)6K;Nw|=&;P@zRzs@59<di>ms
zjO(6l6pHVkD%9F;{X)6EM1P2W`AN)hOQj%9+G3&X32ca;%U&vcP#CKeyo+PAje6O;
zcpx!n;GlsiUWc><!n4(8z33h<%OiV_Hfxn~vCwdr(sHK>2OCU85i{`uVgk0x*KCw4
zW3$DA=eczQ(<WZVD>C$uiOtwz;xLYwIErHe8~=O$;byr~a_c15y6a%|!eF&nY}Q?`
z=q^nSnmCSEC7duZgOdhcGm*t9f&NaWW0#9=tx>M>ip~>#kO`_yui@6+5^vSHh=A4E
znp?Q!7FnVG=Tt_(caAk&7d`voQo~)OT~^a+)v{b2oAGMR2FvLd7TL~C@#i{Z%M8!G
z+?err9$U@S{%VtYC(#*pq?0I6sMTDL<VV{XpK9APoorW<45IOw#Q(U1jcTj+0t4}9
z1DT*zTi$FPA+oPYdKG!~=MkF2ActUpvjXV+@uh$brxv3W(we*jaf=FzL<}gSA3^y@
zsLRmLI6`vsbn^Z|Z7LeMj!ZI|o{nmzjOJ)xA(C{obnFKDDYbdI$SrGYH`jhw>sW5t
zCvL7ilxO(V8A;9@U_hQC=dTA{Bx#arFOsk@jy_D%H$~zRMq1DwLl@#Px`l}T#mJC+
z?QM2f$t}RBY&7x>PDG-Sl3tn5=#Ks+x?@R4*GlOd=%JF1eT{&luSg?Jmh{a>V~%zg
zzLjJ|Mz$Bel_y+>$OEi`PUbzV$xc=!PFCY&FvW2@N!F5M7qq`Qd*OjciXP{%P4DwI
zy)%+tb{##|s&uVQaXx+hDT<1%q}XBQUs=c3zw!*l9Xw|jDGnpS?+E|!CNPRa*p1WJ
z*P*!W3B|2suKMdc&#fUofZweBKZf&uEtl8$)Ad|F5Xj{XBbN^bb9pOZab+16*H+My
zmXH-9h81=xG!=F$>`~aO(6Yjew5={;pEW@2w>A<76gmnwDBNfrp?#CW%?h_Dj97Wv
zqn1mIS!Lo2)+ORrg@X#WDI8L`-Nr+@ci8xoVrNV2YKdW6RB4Q>OC%H~6{Zx9SVQ!V
zDok4w)W>WsMKNxN5)`{_@jb;J+c!zEw<RWQ|3_Tyv;8JT#`ayMn6$3sviG3nZ$rO>
zz^T;z>C{~qBdZ8zw3I)ll^iX`=a<nt3x6iy&lrxL2|7V1@GYE_6HGfA-|n&@mV+Fn
zKW-y*58?bBboH65=yr@%^sJ(H71m9dS$g~WsNZ6HAs&dIV7CYFI5psmn8WL$fHy=5
zv*JCR6&~IcS1>0&##`bOye+=KJK`GN71ybMhx6hATxMAiKcggm#Rc`6lF--0rwAF?
dW?;y`cA-8%-y?cB9fBSSJA&k~Qw`Lve*rM5hM@oe

literal 0
HcmV?d00001

diff --git a/DivideNConquer/Duplicates.java b/DivideNConquer/Duplicates.java
new file mode 100644
index 0000000..7fa49aa
--- /dev/null
+++ b/DivideNConquer/Duplicates.java
@@ -0,0 +1,103 @@
+import java.io.*;
+import java.util.*;
+class Duplicates
+{
+    static void sort(int arr[])
+    {
+        int n=arr.length;
+        for(int i=1;i<n;i++)
+        {
+            int key=arr[i];
+            int j=i-1;
+            while(j>=0 && arr[j]>key)
+            {
+                //move elements greater than key to one space ahead to make space for key
+                arr[j+1]=arr[j];
+                j--;
+            }
+            arr[j+1]=key;
+        }
+    }
+    public static int first(int arr[], int low, int high, int x, int n) 
+    { 
+        if (high >= low) { 
+            int mid = low + (high - low) / 2; 
+            if ((mid == 0 || x > arr[mid - 1]) && arr[mid] == x) 
+                return mid; 
+            else if (x > arr[mid]) 
+                return first(arr, (mid + 1), high, x, n); 
+            else
+                return first(arr, low, (mid - 1), x, n); 
+        } 
+        return -1; 
+    } 
+    public static int last(int arr[],int low,int high,int x,int n)
+    {
+        if(high>=low)
+        {
+            int mid=low+(high-low)/2;
+            if((mid==n-1||x<arr[mid+1])&&(arr[mid]==x))
+            {
+                return mid;
+            }
+            else if(arr[mid]>x)
+            {
+                return last(arr,low,mid-1,x,n);
+            }
+            else
+            {
+                return last(arr,mid+1,high,x,n);
+            }
+            
+        }
+        return -1;
+    }
+    public static void main(String args[])
+    {
+            try 
+            {
+                /*FileReader fr=new FileReader("input.txt");
+                int ch;
+                int arr[]=new int[100];
+                int i=0;
+                int d=0;int num;
+                while((ch=fr.read())!=-1)
+                {
+                    num=0;
+                    while((char)ch!=',')
+                    {
+                        d=Character.getNumericValue((char)ch);
+                        num=(num*10)+d;
+                        ch=fr.read();
+                        
+                    }
+                    arr[i]=num;
+                    i++;
+                }
+                if(ch==-1)
+                {
+                    fr.close();*/
+                    int arr[]={1,1,2,3,4,5,6,7,8,9,9,9,9,9,9,9,10,11,20,23,23,23,23,67,67,67,67,89,101,105,106,106,106,106,106,203,245,245,245,367,8,8,8,8,34,34,52,1067,2345,435,567,567,890,780,657,123};
+                    Scanner sc=new Scanner(System.in);
+                    int i=arr.length;
+                    sort(arr);
+                    int x=sc.nextInt();
+                    int f=first(arr, 0, i - 1, x, i); 
+                    int l=last(arr, 0, i - 1, x, i); 
+                    int c=0;
+                    for(int j=f;j<=l;j++)
+                    {
+                        if(arr[j]==x)
+                        {
+                            c++;
+                        }
+                    }
+                    System.out.println("Number of occurences= "+c);
+                //}
+            }
+             catch (Exception e) 
+            {
+                System.out.println("Exception encountered");
+            }
+    }
+}
\ No newline at end of file
diff --git a/DivideNConquer/Dutch.class b/DivideNConquer/Dutch.class
new file mode 100644
index 0000000000000000000000000000000000000000..0e5916793f7f4b22cf9a034a96bebf8f19f11f91
GIT binary patch
literal 1961
zcmZ`)TXR!Y6#jN|lARn+X__|0kOYcCNh73EvDKDV1d62eCgm0?!fA3Sr<Ww0oN#&2
zCuaN=&L}d&jJ}8uNyjRWJ~-o(PyPbO2mgSh)Nh{zA`pAom$mj<>-*N)d!3)3eE%50
z5!}|X7o$4*@s7m1I(!&Yn{l-|s#X(fH7W6)#IYdW*P-LM#0iO$I(A@6M<-4N@qwC8
z>j)tm#I%~v=$OH52y>VZVnN4;I4iNJW0#7y3+L2uUJVzN?xMsciJU;-s9m((NdaGK
z@PdGLqExU1x@PR6HCNqOww!b3@;W72<+fQCkg26?HmgpC7EH&rUAt5iFdEXC1=DuM
z1v(d9Gru-#mYcSrn^il%Rw+3y{cM;vE&5VRGppt;b7<Wxt_&@@j$K?CAG{!OnY2B+
z<i8}KPu<B|Wfi3&@e%inrK*#+PT2~RezNN3Z)B7o1FzwA0|Pj~5DJD8TrrTspn;EZ
z)xaA#VBi|A3WQ$_Oah+BE)6vt%VKpS<KA(V6O&+{YL8d1U$-2qaMm&lmLm{(s!(PP
zp)y%kLtX#|3a|`Z$BKYBXy68HiB$t@SeMu^P(+Eb7nvBV&~G}9c~_!r;HC<?^F@@$
ztM)ph8gNii1JPBL_gm_;-%G`F+~${8tvoZ{(<ajb9ZOlNS}~sGnZ8nu3TrEtd&#>P
zJgPRlF40uGvI%rI<;@hbl=R+`HFD!ggAS9Yu9rY>YVc)myps7+F>ez2K)Yb=Ec})7
zx=n)v?F`z|?`|>A7F}yaRWn#Nor=Zn|IlO>{(E)qR$Oa?=_yr}K?4@)FYqe6ywH}p
z!Kcv3@bhB6qOv-)&UX+n%Vn!r5J;r5FDIi}a{4*cj@e78Xq^wbrN*OTIlW-)EdA^}
z>c`K2z7`1V<0{FSR~7zr9pVue0{b}zJYkrPg>Q;$b@VN0`~|ww@yuj8o=#-u(~0DK
z%P8WhdpP#8ZAICy`sjdfu<77)YE<-We3Hf^S~Bq!j-->BsCFNbbUe9<j(bAf^NEMs
zzkA{bjFn6%amV(<?O#33FI({C;#whDhxRR<b$ED(`PhIscL_-B=57x`^t0dXB}GMd
zA6vkF944Pp0-8VuX<F#e{(%%C-s2}!Hi;(GPuYbP*U@<5OK6YciGub8dPtnW?<16s
zD^!oX$v>BlAF3g+37O^`q(-WoG=QZU0(hIeN0`)cw(SXKWs)$D5!e)AoyH-Yp?1at
z<cBX11+g5YxI^V#T%@sb@=dt#BSJG<&~uSj>M&-v(3#u9j@-dIy6OneMY_lQ;ldC4
zSb#VpxiRf0bjAEJt%ja4|HJJ+WBy2Q4bd?flaEJ&zL8Kg6b;@-Un~#}#bh)zyotW~
zdm*O(k66GL4Qd5a`3^fHuhtNIc6@-6E$qtG5m$zp8WPHFvWDF??D5QhYw@2(gwW^7
zeF0&9dHS(PQs>C^JU@pQnS~s(xXka?5-#BiEY54V%HDPjpTNXt$m0R$uh~Xb!KM+|
z=0ZwjyuTrdH(Bw+62rhYFWqw*PtnjlL6`<Y{Ds)x=;buX3k?=o5QkueRK-UA1tMLZ
A2LJ#7

literal 0
HcmV?d00001

diff --git a/DivideNConquer/Dutch.java b/DivideNConquer/Dutch.java
new file mode 100644
index 0000000..fbd7cd8
--- /dev/null
+++ b/DivideNConquer/Dutch.java
@@ -0,0 +1,104 @@
+import java.io.*;
+
+class Pair {
+	private int x;
+	private int y;
+
+	Pair(int x, int y) {
+		this.x = x;
+		this.y = y;
+	}
+
+	public int getX() { return x; }
+	public int getY() { return y; }
+}
+
+class Dutch
+{
+    public static void swap (int[] arr, int i, int j) {
+		int temp = arr[i];
+		arr[i] = arr[j];
+		arr[j] = temp;
+	}
+
+	// Partition routine using Dutch National Flag Algorithm
+	public static Pair Partition(int[] arr, int start, int end)
+	{
+		int mid = start;
+		int pivot = arr[end];
+
+		while (mid <= end) {
+			if (arr[mid] < pivot) {
+				swap(arr, start, mid);
+				++start;
+				++mid;
+			}
+			else if (arr[mid] > pivot) {
+				swap(arr, mid, end);
+				--end;
+			}
+			else {
+				++mid;
+			}
+		}
+
+		// arr[start .. mid - 1] contains all occurrences of pivot
+		return new Pair(start - 1, mid);
+	}
+
+	// Three-way Quicksort routine
+	public static void quicksort(int[] arr, int start, int end)
+	{
+		// base condition for 0 or 1 elements
+		if (start >= end) {
+			return;
+		}
+
+		// handle 2 elements separately as Dutch national flag
+		// algorithm will work for 3 or more elements
+		if (start - end == 1)
+		{
+			if (arr[start] < arr[end]) {
+				swap(arr, start, end);
+			}
+			return;
+		}
+
+		// rearrange the elements across pivot using Dutch
+		// national flag problem algorithm
+		Pair pivot = Partition(arr, start, end);
+
+		// recur on sub-array containing elements that are less than pivot
+		quicksort(arr, start, pivot.getX());
+
+		// recur on sub-array containing elements that are more than pivot
+		quicksort(arr, pivot.getY(), end);
+	}
+    public static void main(String[] args)throws Exception
+    { 
+        String arr[] = new String[100]; 
+        File f=new File("num.txt");
+        BufferedReader br = new BufferedReader(new FileReader(f));
+        String st; 
+        String s2="";
+        int num[]=new int[100];
+        while ((st = br.readLine()) != null) 
+           {
+               s2=s2.concat(st);
+           }
+        String words[]=s2.split(",");
+        int n=words.length;
+        for(int i1=0;i1<n;i1++)
+        {
+            num[i1]=Integer.parseInt(words[i1]);
+        }
+        quicksort(num,0,n-1);
+        System.out.println("Sorted array");
+        for(int j1=0;j1<n;j1++)
+        {
+            System.out.print(num[j1]+",");
+        }    
+        
+    }
+}
+    
\ No newline at end of file
diff --git a/DivideNConquer/Histo.class b/DivideNConquer/Histo.class
new file mode 100644
index 0000000000000000000000000000000000000000..7d6bd23a138955187c685204d246a79bfd0ebbd0
GIT binary patch
literal 946
zcmaJ<OHUI~6#j1K&ZENs6_|pwRRq*&kyb%bLyG|uL$x?2H6#-@4s-&8eWgr|?)ew)
z*syV<i$c_pxb;W)Lx=&-9Wba67x$cV&pnUtJNJA)`g{Q3E*|RW!LW`5l0u|(bmK}C
zS23dEnhpiS8b*a46JlJ5>pE`WrV2|%nnB6?bw8M6kgW7F1ApA8cnrNIzwSM6*H*pO
zOLw(O9`3e0mqE5xis>RlcR6s^UN5=L-_JGIuQSB0mC~mB#?4jT`g*P$wEX(|tf;G(
z8|~Jb_rw>q^hJLwXk<m8fnLN^WDHE;mVrqj`Z1s)YaoZ)41@ocTWI^$iq|4U^MuI2
z9ZU%^ZO}CCshBZv9}fs<*n=T<mT#|adTRkg&zWn<4K|2+&3!AV6+>!LO)&W*ul#N+
z@M;v+Xj8U%LeOvIUJ$#0IC^evmImoIn_j)bFlk*df^)7@8kCr{is}D6YeC~=jtm3V
z`9LbrAM*Jd5QEwj@Tx?`ya>=TMrc)fXo&!c4t)a{E|HZY%}C3cJ+O~tF!YgBLT3b;
z_#d)G=nkbSq@PN8sUXdzG6y?&lu2b1`-tR87gD@3!%hAkV;PfYllzbgCQnuPs~I_w
zH02Eux6O}tkAG}SZ1?zE;saHSg#EJU3cGTsFc77lI)=zMO0Xvg_%uPz(|v*77b(M}
z=sxfxD2%b6h_geCA3~<gI0jGgHo-%(rC9W<?nvBrxNJMJVmk^QRka;Wvz?d{qgzZB
zrl#7ZiGA?GC&*u*ID1h0v<{-l4)hMXIxx;AMBNEPoR)YHQ-t*yhN<sR$msGf`Io^Z

literal 0
HcmV?d00001

diff --git a/DivideNConquer/Histo.java b/DivideNConquer/Histo.java
new file mode 100644
index 0000000..08e25f6
--- /dev/null
+++ b/DivideNConquer/Histo.java
@@ -0,0 +1,27 @@
+import java.util.*;
+class Histo
+{
+    static int area(int arr[])
+    {
+        int maxarea=0,minht=0;
+        for(int i=0;i<arr.length;i++)
+        {
+            maxarea=Math.max(arr[i],maxarea);
+            minht=arr[i];
+            for(int j=i-1;j>=0;j--)
+            {
+                minht=Math.min(arr[j],minht);
+                int width=(j-i+1);
+                maxarea=Math.max(maxarea,(minht*width));
+            }
+        }
+        return maxarea;
+    }
+    public static void main(String args[])
+    {
+        int arr[]={1,2,3,3,4,5,6,5,4};
+        int a=area(arr);
+        System.out.println("Area"+a);
+        
+    }
+}
\ No newline at end of file
diff --git a/DivideNConquer/Hoare.class b/DivideNConquer/Hoare.class
new file mode 100644
index 0000000000000000000000000000000000000000..4480a5be4a89487e872ca96e5d8f338a760296b7
GIT binary patch
literal 1752
zcmZ`(T~ixX7=8}f-LqL22!RDc60Kh}2@qPuv<8ZmN^OvjS}JYC50+%XE%|cUIPHaZ
z%=jC;Y;}ei^`^Z@7|~vO;rIvq30`>LaU9}%HbA7rndCiZ-|y!+?>WC6{`3^UBtF*=
z!9@*WObGD?$0Wy_DpDF`T;jOQ@s<WZ(i&7ushAe)6%7(*RJ<+Ls~X<HtRL6#u8KJg
z*YO_54Go4!Yak=Uyb$jT+XBZT#}b1wZI^6!hQSw$uQEv2%6W^Sd%-SQOV#3r<=i$m
z3Z(H@OvkldyIf-6v9(Ml6VEVouDE7yd(o^Mdwo&0bK5&*$35{9NsFdUVg0eSg?r|g
z=6Jy@ZH=$Ej$PWCim!4k6I2f(VZO<r&E3yg6;W!3;{*C$DOa7Gb=?+yXgA8HV<kl%
z9Z|ff<7K>}<2Ag_5O_X2gYK#9@^~|vm#W32d*2nIx2U6I>uhy%({il*Ez8VX4ny$R
zAi|nT5war0Z3gK05UV=w;4T9j)se+V9BVp0#wQ$~>i7)nRC|SZu=3|j$1xvpP`?|Z
z=)m(`&Q|RLRn?J0UI<IarpUe}yk!sXDQwFd_pBTd+}nmuhK@Blm)=&56EYc$SUdh1
zdXDr*G|`z*hL*00-_xoN5hP}Vp)VFcn~mlvS1#pD>TbAQv33#iPNiT|!1;CoZ6Wrw
z&}B-lwIxnWrTN^k=<|PI5-I;3j|V%hRivRWS4BXxErNfOX40j}w9MkvF^i|wG}jg3
zRG@)Y%u2;7<ryNe%vmyyj+OF^wL^A>ik83XmYcVOj^8VWbMz)e=%D~zbcnGB!%N<d
z=8sl6Q3rcW8%C~x;wd}miJ;4I<oXSTa<a`O!pWJilut<!X+0(HN-SYW$>_tzvt7B7
zFyv(P+r~3PGUSI)4EaZ4OerLVX_<tfEbldbr$ilIsR_CZqM%6LMf)CfB7^{S+e4SK
z7bECHl3txj^kW(Wn8hGor3ekaLv%65v_5K+uJ2Ks3-Eau!{Nvy3?{;neRRwu!qI*B
z5>aWLK79gbvv@x}j)D%E$k3^sAmJUN^rC<dY=|DrVVoyt;)>lNH;oKG1oFQ?S~!55
z4Jvi;#RI6>1NgI}b!c_GuoTqOav=Y+mR81U=**_2U(p?sLsAW0X?d^lS4a+a*APha
z5PzCdeJQ`;H`GVy4=IK}#0~$%K6;jS{cNxCXGrlGs+6aupCB0Qt)cJ4eV8-{FtYV#
zV6uh*k#?|#Pz^&~_#Z8#^MnlqMj<!>#0YDGNE;zJO4KHC6&H}fMJ!<gcS&Q>x{Va7
zxP-588DArf?`ZuVS3Gv+p)@F%bHuz~oQp4vaLR`Uo!2RgXK30E5ugCZ{zm8@^wAQ>
R7<DGm@g?a$PWujA_!l3Jb&LQ2

literal 0
HcmV?d00001

diff --git a/DivideNConquer/Hoare.java b/DivideNConquer/Hoare.java
new file mode 100644
index 0000000..c20d5b9
--- /dev/null
+++ b/DivideNConquer/Hoare.java
@@ -0,0 +1,62 @@
+import java.io.*;
+class Hoare
+{
+    static int partition(int arr[],int lo,int hi)
+    {
+        int pivot = arr[lo];
+        int i=lo-1,j=hi+1;
+        while(true)
+        {
+            do
+            {
+                i++;
+            }while(arr[i]<pivot);
+            
+            do{
+                j--;
+            }while(arr[j]>pivot);
+            
+            if (i >= j) 
+            return j; 
+            int temp = arr[i]; 
+            arr[i] = arr[j]; 
+            arr[j] = temp;
+        }
+    }
+    static void quicksort(int []arr, int low,  
+                                 int high) 
+    { 
+        if (low < high) 
+        { 
+            int pi = partition(arr, low, high); 
+            quicksort(arr, low, pi); 
+            quicksort(arr, pi + 1, high); 
+        } 
+    } 
+    public static void main(String[] args)throws Exception
+    { 
+        String arr[] = new String[100]; 
+        File f=new File("num.txt");
+        BufferedReader br = new BufferedReader(new FileReader(f));
+        String st; 
+        String s2="";
+        int num[]=new int[100];
+        while ((st = br.readLine()) != null) 
+           {
+               s2=s2.concat(st);
+           }
+        String words[]=s2.split(",");
+        int n=words.length;
+        for(int i1=0;i1<n;i1++)
+        {
+            num[i1]=Integer.parseInt(words[i1]);
+        }
+        quicksort(num,0,n-1);
+        System.out.println("Sorted array");
+        for(int j1=0;j1<n;j1++)
+        {
+            System.out.print(num[j1]+",");
+        }    
+        
+    }
+}
\ No newline at end of file
diff --git a/DivideNConquer/Matrix.java b/DivideNConquer/Matrix.java
new file mode 100644
index 0000000..823d765
--- /dev/null
+++ b/DivideNConquer/Matrix.java
@@ -0,0 +1,170 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class Matrix {
+
+    private static int[][] StrassenMultiply(int[][] A, int[][] B) {
+
+        int n = A.length;
+
+        int[][] res = new int[n][n];
+
+        // if the input matrix is 1x1
+        if (n == 1) {
+            res[0][0] = A[0][0] * B[0][0];
+        } else {
+
+            // first matrix
+            int[][] a = new int[n / 2][n / 2];
+            int[][] b = new int[n / 2][n / 2];
+            int[][] c = new int[n / 2][n / 2];
+            int[][] d = new int[n / 2][n / 2];
+            
+            // second matrix
+            int[][] e = new int[n / 2][n / 2];
+            int[][] f = new int[n / 2][n / 2];
+            int[][] g = new int[n / 2][n / 2];
+            int[][] h = new int[n / 2][n / 2];
+
+            // dividing matrix A into 4 parts
+            divideArray(A, a, 0, 0);
+            divideArray(A, b, 0, n / 2);
+            divideArray(A, c, n / 2, 0);
+            divideArray(A, d, n / 2, n / 2);
+
+            // dividing matrix B into 4 parts
+            divideArray(B, e, 0, 0);
+            divideArray(B, f, 0, n / 2);
+            divideArray(B, g, n / 2, 0);
+            divideArray(B, h, n / 2, n / 2);
+            
+            /** 
+              p1 = (a + d)(e + h)
+              p2 = (c + d)e
+              p3 = a(f - h)
+              p4 = d(g - e)
+              p5 = (a + b)h
+              p6 = (c - a) (e + f)
+              p7 = (b - d) (g + h)
+            **/
+           
+            int[][] p1 = StrassenMultiply(addMatrices(a, d), addMatrices(e, h));
+            int[][] p2 = StrassenMultiply(addMatrices(c,d),e);
+            int[][] p3 = StrassenMultiply(a, subMatrices(f, h));           
+            int[][] p4 = StrassenMultiply(d, subMatrices(g, e));
+            int[][] p5 = StrassenMultiply(addMatrices(a,b), h);
+            int[][] p6 = StrassenMultiply(subMatrices(c, a), addMatrices(e, f));
+            int[][] p7 = StrassenMultiply(subMatrices(b, d), addMatrices(g, h));
+
+            
+           /**
+              C11 = p1 + p4 - p5 + p7
+              C12 = p3 + p5
+              C21 = p2 + p4
+              C22 = p1 - p2 + p3 + p6
+            **/
+           
+            int[][] C11 = addMatrices(subMatrices(addMatrices(p1, p4), p5), p7);
+            int[][] C12 = addMatrices(p3, p5);
+            int[][] C21 = addMatrices(p2, p4);
+            int[][] C22 = addMatrices(subMatrices(addMatrices(p1, p3), p2), p6);
+
+            // adding all subarray back into one
+            copySubArray(C11, res, 0, 0);
+            copySubArray(C12, res, 0, n / 2);
+            copySubArray(C21, res, n / 2, 0);
+            copySubArray(C22, res, n / 2, n / 2);
+        }
+        return res;
+    }
+
+
+    public static void main(String[] args) throws NumberFormatException, IOException {
+
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+        System.out.println("Enter the order of Matrices:");
+        int order = Integer.parseInt(br.readLine());
+
+        int[][] A = new int[order][order];
+        int[][] B = new int[order][order];
+        
+        int[][] res = new int[order][order];
+        
+        // input : first matrix
+        System.out.println("Enter first matrix:");
+        for (int i = 0; i < order; i++) {
+            for (int j = 0; j < order; j++) {
+                A[i][j] = Integer.parseInt(br.readLine());
+            }
+        }
+
+        // input : second matrix
+        System.out.println("Enter second matrix:");
+        for (int i = 0; i < order; i++) {
+            for (int j = 0; j < order; j++) {
+                B[i][j] = Integer.parseInt(br.readLine());
+            }
+        }
+
+        res = StrassenMultiply(A, B);
+        printMatrix(res);
+    }
+    
+    // helper methods
+    
+    // Adding 2 matrices
+    public static int[][] addMatrices(int[][] a, int[][] b) {
+        int n = a.length;
+        int[][] res = new int[n][n];
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                res[i][j] = a[i][j] + b[i][j];
+            }
+        }
+        return res;
+    }
+
+    // Subtracting 2 matrices
+    public static int[][] subMatrices(int[][] a, int[][] b) {
+        int n = a.length;
+        int[][] res = new int[n][n];
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                res[i][j] = a[i][j] - b[i][j];
+            }
+        }
+        return res;
+    }
+
+    // print matrix
+    public static void printMatrix(int[][] a) {
+        int n = a.length;
+        System.out.println("Resultant Matrix ");
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                System.out.print(a[i][j] + "\t");
+            }
+            System.out.println();
+        }
+        System.out.println();
+    }
+    
+    // divides array
+    public static void divideArray(int[][] P, int[][] C, int iB, int jB) 
+    {
+        for(int i1 = 0, i2 = iB; i1 < C.length; i1++, i2++)
+            for(int j1 = 0, j2 = jB; j1 < C.length; j1++, j2++)
+                C[i1][j1] = P[i2][j2];
+    }
+
+    // copies
+    public static void copySubArray(int[][] C, int[][] P, int iB, int jB) 
+    {
+        for(int i1 = 0, i2 = iB; i1 < C.length; i1++, i2++)
+            for(int j1 = 0, j2 = jB; j1 < C.length; j1++, j2++)
+                P[i2][j2] = C[i1][j1];
+    }  
+    
+}
\ No newline at end of file
diff --git a/DivideNConquer/MaxMin$Pair.class b/DivideNConquer/MaxMin$Pair.class
new file mode 100644
index 0000000000000000000000000000000000000000..281c6a71737a74652d62b62419d8a75e91b85d04
GIT binary patch
literal 273
zcmX|5yNbe46r7W2;>P&iR<N+x-C}JlWg9^de1Wq4jb7wRyh5VlZ&?Xj_yPM-;zYq_
zUNGm(|LyMzpo{kaE=oQsKI#H@Ypg(qnNlZ#*E81ae`r5Ge+9YzZlwj4k+FJm*hV^8
zs3>L<%y)-msRt%A#j!e#js4!JqYB}p;G^+M+cRYnUV2hEv{onmSf!~>1=Xz5iIrV<
zrqM<(_gwHih87$S1rf+0PXxRN3l*P0@J7`nXG#9+0y$G~9MOA(F6%`)2O(<YfT@Er
Hswmt61B))0

literal 0
HcmV?d00001

diff --git a/DivideNConquer/MaxMin.class b/DivideNConquer/MaxMin.class
new file mode 100644
index 0000000000000000000000000000000000000000..dff297049f99a660090068c0e0798be97ed2759f
GIT binary patch
literal 1178
zcmZuw+fEZv6kVsCTZchf5CmGKDq<;2tD=}t#0L|S8lWUKn#RO1z}Sqo18Jv5;}7`a
zo3AFukdXL<#tTu=`0AJV5yrUAlxs9;&)H{R*4}HKGe7@){s!POu9}D;rQ@WD2vRXF
zr{pqZq7&&DPUDP$vpR-NoWqET^T-$&)sYoY79Fo4U=@AeZQQ6i&8FKF(55}#3uXkO
znbF%!y0NzE3UtkRzPr$>FT0If&T@^OSk(>YJ%8SLEYOp=TPzkw=XjuNSmG80I?I8x
z@^Ic+4=Xq!(dv%p3-o2~&OLA*Ir*C7SM%kd;rZ2q>}HnNT8$NV){`AN+Hg6UX(5ip
zzANltVGQFIY`Gjqua2CBJT4I3<PcuHRZqJ$x9<8u+H0oItqQ~sdX|<SxGRB<ixw_n
zLdRtbS1=jYI*<QXtF?!rEOp616s0A(9|A2uX$Eecfwfj3(A%cyt>qWVFCa_TsZ*B3
z!4yS5aH}rwK!4=aT5jpSl!iL~lfkl{(0LS%x3w;@SvQ?IRJE(<VUgQ}3%l4yVG2m|
zvBdbCfGGcz8Uo$4PI4FA)$AvTw=_5hS1oi37*crJOciC8>WuyPf=J~Pq6@qGl(J{2
z$<!<K*x6+61C;ir+FPllvh)h_m`&w2aC|So6Vo=4utQ7TtJ_MZmeks$mQD6*+t8+z
zY_Fy)rKG72DDR;Rs9av7%MMQ=hGmCN+R~@WgSxSsp?-k6iFSsx?Jbgsgfy4YPun8R
zPAYN?gH&dSWJegaNj;A~OyUHtV*s;^E>f>MIE8!Ea|vfq#aXOl7*AR83>mz@I9?)$
zH@JY0n80_wxjuI2hw%q_9Vgnqbf@@@31Rdbypw)nx9{RPWmlN(#I>(xC7Ou-Dpizt
zN2#JF#7?QADW!^@5I0K|Bhj&4nu}}K#-b@@mBK8%gWhc@JBU@HHpSWIclHq-cck0e
tcdL8ugL@uiOJIuQ7ch!xek#{c#0<$@r$mE{MUX@ncauX#DAO?*e*y2v?85*6

literal 0
HcmV?d00001

diff --git a/DivideNConquer/MaxMin.java b/DivideNConquer/MaxMin.java
new file mode 100644
index 0000000..e2c3f08
--- /dev/null
+++ b/DivideNConquer/MaxMin.java
@@ -0,0 +1,64 @@
+class MaxMin
+{
+    static class Pair 
+    { 
+        // to return 2 values from a function
+        int min; 
+        int max; 
+    } 
+   
+    static Pair getMinMax(int arr[], int low, int high)
+    {
+        Pair p=new Pair();
+        Pair mml=new Pair();
+        Pair mmr=new Pair();
+        int mid;
+        if(low==high)
+        {
+            p.min=arr[low];
+            p.max=arr[low];
+            return p;
+        }
+        if (high == low + 1) { 
+            if (arr[low] > arr[high]) 
+            { 
+                p.max = arr[low]; 
+                p.min = arr[high]; 
+            } else
+             { 
+                p.max = arr[high]; 
+                p.min = arr[low]; 
+            } 
+            return p; 
+        } 
+        mid = (low + high) / 2; 
+        mml = getMinMax(arr, low, mid); 
+        mmr = getMinMax(arr, mid + 1, high); 
+        
+        if (mml.min < mmr.min)
+         { 
+            p.min = mml.min; 
+        } 
+         else 
+        { 
+            p.min = mmr.min; 
+        } 
+        if (mml.max > mmr.max) 
+        { 
+            p.max = mml.max; 
+        } else
+        { 
+            p.max = mmr.max; 
+        } 
+        return p;
+    }
+    
+    public static void main(String args[])
+    {
+        int arr[] = {1000, 11, 445, 1, 330, 3000}; 
+        int arr_size = 6; 
+        Pair minmax = getMinMax(arr, 0, arr_size - 1); 
+        System.out.printf("\nMinimum element is %d", minmax.min); 
+        System.out.printf("\nMaximum element is %d", minmax.max); 
+    }
+}
\ No newline at end of file
diff --git a/DivideNConquer/Missing.class b/DivideNConquer/Missing.class
new file mode 100644
index 0000000000000000000000000000000000000000..ad40ee9f3f9f1c32d510b940a856b5b023f864ae
GIT binary patch
literal 1720
zcmaJ>OHUhD6#lL~<FU;EcMJ{>+le7O{NR;@7+M}pAS9)QxDqXu#U{ocB}2hR#;)3C
zi&S+{sa<!IqDV+p7I{<<H7UDpn*Y&%P^qe#(r>P<kT$56{GD^pJ@=gNJnUcp{^<z7
zIBo<HLSGOT`V9;OFo;ADUL;*h$~~qH3<cpwpC7}n9C2aPg|Q$m;G%&`evBKqY#<}x
zn|4Z0bymQeNUjQK^W~x~(7NQ5?3=Z%b-VImetnY`ZKqtR3h0ToMc1!+rJ65%vYg*;
zT>EzHe5G(lz)uH$l8bz@m3K-4XA)~m8~IQ3qnr8C?a`HL#VOsMO0F81Ffhpy$VVW!
zQm$1B_I1b2WiC5AJM<cHpP6VwyNPZ@1S}P&R&_Q<R|@%3$*vf9%f#E5a=oTabfDA3
z3|LObe^buYoXw(LVUR}jcuCb4cXmv?gDWmvH8F>I1J_I};JQHDNsxul3ifu@DYKyP
zD?M(P3gud<YFF%{fYAsnAWz<9*Ej3}8`pM969hbK?9*%BE1&OF?Je5f#)a!`bIPNO
zrR`dkowM^>Qv#idQ!m`Hc*`~BI(hg3n|<=om*3vDOJq9Si14q8yfLIk$CxpiSWN!U
zwZB@fk5!;O@unjK)Emi4UL(YYZM*a~-BM2@w2C-)I>fC9G=8}UpewZ)rJ&SPhY*jb
zaLb53W%P2>xd+r;*Khb#r<_e4O=~mJ$R0AO=*VnTD`vE?_8lUrur?CAk2Xr}mV3zV
zYRCJ>zo~O9yXz7A$1mI*9+e}7Aa#SkI6t)@TF^vdCaJa}1&J{dp5WaK$#&6GLVF2a
zh?i&<BKikC{q8O|*nQPtcQqRM9y5_>q^NJ+%4mwyJ@~@f1EubvMbU}Ip2AZ%-KQx+
z%0*@JJa|QL00HV9EV_&2x=A`p?JRmoaR|Nq2kGOc4=Qr}<M<0*BJ?Lo2k7Val}+<p
zAuWSl{aH>v59YjDHmC8c>)D*om(3YQHs|+ebJ8byl7{42`lV|L$N({@ut}k*uvuY?
z!d8V+2I*<ZCSpjo6We45v0Y(U;TeS;a-Q~1g<T4}6-H!^_NcUpG3gM`$_?T<g>i*F
z3VRivxA213eHMPF=&y@`x)`)XnZ|@FBB?N?Fs*P%_VRXE;fNfkK5A)ciZLsYq_|*-
zClnVg&jiJ#x)`^-U+{F<@|qMG%kwS8guI(wdIoRqF|<SI%ju)p^i%lKF|9a~(X@;n
z*4?4*VKVKdEv$3k8DH4vxrg{;7|-C(9U>449-t|#AHY07^8s4+5!ltar@!pOT%ub@
z()ftOgm@^Pa5L+>J4+3i6RVgPd0Z1kEQmX}A<B4H+{Jt1OS~_>#<JMQP4NS553$PE
uE8<6dB%b4AwKDzCk3|JO17{7KGY}VoX(o=jZ-O?4H_+o}>RzVu;QT*)>0R9b

literal 0
HcmV?d00001

diff --git a/DivideNConquer/Missing.java b/DivideNConquer/Missing.java
new file mode 100644
index 0000000..136c26f
--- /dev/null
+++ b/DivideNConquer/Missing.java
@@ -0,0 +1,88 @@
+import java.io.*;
+import java.util.*;
+class Missing
+{
+    static void sort(int arr[])
+    {
+        int n=arr.length;
+        for(int i=1;i<n;i++)
+        {
+            int key=arr[i];
+            int j=i-1;
+            while(j>=0 && arr[j]>key)
+            {
+                //move elements greater than key to one space ahead to make space for key
+                arr[j+1]=arr[j];
+                j--;
+            }
+            arr[j+1]=key;
+        }
+    }
+    static int search(int arr[],int l,int r,int x)
+    {
+        if(r>=l)
+        {
+            int m=l+(r-l)/2;
+            if(arr[m]==x)
+            {
+                return m;
+            }
+            else if(arr[m]<x)
+            {
+                return search(arr,m+1,r,x);
+            }
+            else if(arr[m]>x)
+            {
+                return search(arr,l,m-1,x);
+            }
+        }
+        return -1;
+    }
+    public static void main(String args[])
+    {
+            try 
+            {
+                /*FileReader fr=new FileReader("input.txt");
+                int ch;
+                int arr[]=new int[100];
+                int i=0;
+                int d=0;int num;
+                while((ch=fr.read())!=-1)
+                {
+                    num=0;
+                    while((char)ch!=',')
+                    {
+                        d=Character.getNumericValue((char)ch);
+                        num=(num*10)+d;
+                        ch=fr.read();
+                        
+                    }
+                    arr[i]=num;
+                    i++;
+                }
+                if(ch==-1)
+                {
+                    fr.close();*/
+                    int arr[]={1,1,2,3,4,5,6,7,8,9,9,9,9,9,9,9,10,11,20,23,23,23,23,67,67,67,67,89,101,105,106,106,106,106,106,203,245,245,245,367,8,8,8,8,34,34,52,1067,2345,435,567,567,890,780,657,123};
+                    Scanner sc=new Scanner(System.in);
+                    int i=arr.length;
+                    sort(arr);
+                    //int x=sc.nextInt();
+                    int max=arr[i-1];
+                    for(int j=1;j<max-1;j++)
+                    {
+                        int index=search(arr,0,i-1,j);
+                        if(index==-1)
+                        {
+                            System.out.println("Missing number is"+j);
+                            break;
+                        }
+                    }
+                //}
+            }
+             catch (Exception e) 
+            {
+                System.out.println("Exception encountered");
+            }
+    }
+}
\ No newline at end of file
diff --git a/DivideNConquer/NumeroUno.class b/DivideNConquer/NumeroUno.class
new file mode 100644
index 0000000000000000000000000000000000000000..903332952f5cf27495a04d47ce676c9c3ed63f7a
GIT binary patch
literal 1672
zcmaKsTW=dh6vzK#&wB06#&IqS1>40fZR$(oq(EID7iddEQ`|b>HV}eD9D5VFIJ=f(
za}jSSZ%7Cvc&K=QUZlK4NXbJ|H7Fkdz6TF{0#s4Le{3sGNyM&p_S|O9@0^+4-~M^D
z3*Z%8GtiGg1ARE7hPaMI07;|_NSsxcA*H5u3>yew(2o)IKBtD4)bO&wMb7KU_;EqU
zt2$m2@Qsz7a(zO;8&Av#$jffY7U;>A9s5ROdBLvTEG$%Lkt=SkE}+Hdrc_*azFsJP
za=lP(yS2q~ZH4{-{pw0gaZ072OmewUb_AY@&t-2HJ}nGa3eM7SzFsRkOQVSy9k1&c
zWhKNCF!FArR<tL}DrJxWcFn!zxM?-f!~iT4VMI(s5fSKZF4w4+E5rF>!Ex-GjxiJC
zm{6f_m^g;#OuUJU0?+<8^QA_)QnG8rYE>C?7h`U**r?e~(OwyknYe_@YIw`U6-?@Q
z+r(9{sQ%7MS3WP=)q2@wan`;Z;{tBOsoOQX#CGhLAQ0-z%q`rui)>B*5iJq$%rVb_
z==>Keb$gk1)kdq;#Iid)<y0GW_R%gZj|v=%AL&qg<#ij()tNZW)^{fQ3e~FZkaeiN
z!c+TmXv^A-W5!5)D)B#Vf8A|uvcN$6a3B|GwUU(_020uv3a_F{Jql<BF&^}Oeh+}g
zhi3xZMM_b=g|a5MAvP#*+d2B0Mlby8I8auh-|~Y|lP8k9V{$wazK2XQlAegjQbt<x
zM}(7>Oh+G}pKm#@l-#P^Tig4isYi3G9<jFfyUO8d=19VztV3lncn8r%M3bmJ{2)UZ
zA@T+K#)<npBSVl+pb7B=-9kkEVq`#_>o(nYWb-j98wuaV)o>(S(kk;A&C>3mJDRjK
zSxP@ZkU~28Gklh|u8cH=ly5!~wd6y1){|is*;YL3`>ZF)0a9!1N01#kO`<rnk1+o@
zj^i4s6=N6V--rrh;Bga=UtAmShc@1{!pk1OW3Ng-wGrpj_nty*(kjFbm3RFBuXp_r
z;wk1CB;pw)c%MazKd&KN#5vr+`3~ZVeZ=E<p@k^k;nV<Y*a-!HHD<lu+^m$jS&fg6
zk51jscgRN}q_j{|4JgS_LznWJO6r!m><;AYCbVt%uBUb<QV*faj7)i>vSi69Tb<E5
ziZ|o)W^_x-_$|NXyALa6`O}u<KCS9v)z4$|=O+9+2+VH7=<C{oY3W<&-a>E-J!>$t
z^!D{q-e4)fFWBH=X&tgj^wKiT-_g4q-$S1F`?!e@aSKbBL7m!X_yAwg@-;rfH<Z7}
y$6UkaDht>|36HSY>|7Gs9==3CM@+{F9VbQe0{R{+54V~gHN5C2$0_FZ;Pk(C0ZK6d

literal 0
HcmV?d00001

diff --git a/DivideNConquer/NumeroUno.java b/DivideNConquer/NumeroUno.java
new file mode 100644
index 0000000..ad10c6c
--- /dev/null
+++ b/DivideNConquer/NumeroUno.java
@@ -0,0 +1,103 @@
+import java.io.*;
+import java.util.*;
+class NumeroUno
+{
+    static void sort(int arr[])
+    {
+        int n=arr.length;
+        for(int i=1;i<n;i++)
+        {
+            int key=arr[i];
+            int j=i-1;
+            while(j>=0 && arr[j]>key)
+            {
+                //move elements greater than key to one space ahead to make space for key
+                arr[j+1]=arr[j];
+                j--;
+            }
+            arr[j+1]=key;
+        }
+    }
+    public static int first(int arr[], int low, int high, int x, int n) 
+    { 
+        if (high >= low) { 
+            int mid = low + (high - low) / 2; 
+            if ((mid == 0 || x > arr[mid - 1]) && arr[mid] == x) 
+                return mid; 
+            else if (x > arr[mid]) 
+                return first(arr, (mid + 1), high, x, n); 
+            else
+                return first(arr, low, (mid - 1), x, n); 
+        } 
+        return -1; 
+    } 
+    public static int last(int arr[],int low,int high,int x,int n)
+    {
+        if(high>=low)
+        {
+            int mid=low+(high-low)/2;
+            if((mid==n-1||x<arr[mid+1])&&(arr[mid]==x))
+            {
+                return mid;
+            }
+            else if(arr[mid]>x)
+            {
+                return last(arr,low,mid-1,x,n);
+            }
+            else
+            {
+                return last(arr,mid+1,high,x,n);
+            }
+            
+        }
+        return -1;
+    }
+    public static void main(String args[])
+    {
+            try 
+            {
+                /*FileReader fr=new FileReader("input.txt");
+                int ch;
+                int arr[]=new int[100];
+                int i=0;
+                int d=0;int num;
+                while((ch=fr.read())!=-1)
+                {
+                    num=0;
+                    while((char)ch!=',')
+                    {
+                        d=Character.getNumericValue((char)ch);
+                        num=(num*10)+d;
+                        ch=fr.read();
+                        
+                    }
+                    arr[i]=num;
+                    i++;
+                }
+                if(ch==-1)
+                {
+                    fr.close();*/
+                    int arr[]={0,1,1,1,0,1,0,0,1,0,0,1,0,1};
+                    Scanner sc=new Scanner(System.in);
+                    int i=arr.length;
+                    sort(arr);
+                    int x=1;
+                    int f=first(arr, 0, i - 1, x, i); 
+                    int l=last(arr, 0, i - 1, x, i); 
+                    int c=0;
+                    for(int j=f;j<=l;j++)
+                    {
+                        if(arr[j]==x)
+                        {
+                            c++;
+                        }
+                    }
+                    System.out.println("Number of occurences= "+c);
+                //}
+            }
+             catch (Exception e) 
+            {
+                System.out.println("Exception encountered");
+            }
+    }
+}
\ No newline at end of file
diff --git a/DivideNConquer/Occurence.class b/DivideNConquer/Occurence.class
new file mode 100644
index 0000000000000000000000000000000000000000..39af76c483402d327ffc80d741682a3e308f405c
GIT binary patch
literal 1888
zcmaJ>T~k|C6kR8|H#Z5Fa4ry_O+o|ZBOj1J3!%zKwODLw+Mub-WY8Hxa;+D`4HFWl
z>T7?1Jow=FpmsXL3oor5V64OFtNkDT14qZP;yx!C0@5)vS^J#5SN2(F@3ZskKR+G;
zn8G_=_%ZB7H%0`EYKV9cMa&BYap4&gt8w8=Xh?eD#jqO_!cGdfBH*f*GEKXY(lF!3
zH4U$6c%8vDXW3S5fx#Jxt}rNzm6FNOk+E#^ZhdpztllfEm&v1SSE@AzHL{u(y!KqJ
zQ2gXhVXGNdKeDRZ6!%bEe4=UkNx2|g%4Wf`8G0hCnT^7yg=D#4-%sXhRm;9V8(kqa
z4BlL&UM-qSmN?0mEf(ul(=M6`!Pn7)UL7Iy>$rq|21914*Q|0fS1j1JS=BJBV-E9z
zx}f7C0y?ha4IOXd21D<EPrXsM$|bYP(6uB)hvj+l!0>!n$0FVma8t(;-qvtSM;f;o
zIx}>evs}v1%6;=e(cG$86}qbbWF4k!RO)uktePb%&dJRfc<Yzh^$oK~g*xTReYRaQ
zHyIqFa{fl$tV%L%Z`Es5I<v4j%g`5jWk9q?v&{#!v`tB=t<(x<rB3TsqGhUnE0L?P
zwPo5QaJ-rEOpDHStyw=(5R9aw{}XoCDvdrfbVtq;DM6!tbhA@}Nd1<OR~A=)m7o=b
z>CO9TGys*p^gck<pjC)06W-VX*b`bXTp)BwrxR}RG-xfTU(&>gA1}m?=9Kwh;1N=>
zU}7Ptlv0Xc`38ZQUrB@>ql>JvCN|lJ%JJ^;Z*m{XK6J3%;}_x#hdd)jBL-*?r-*U$
zp$%QoNoogT;Fv%sW+*mK(u2h0P+mf1>?PV63;sz=k9gxvbvvZZMXXFP@I7t?f`O7+
zUQ4Nd^=q_;Vt!RAB_6{^i$v%<xcus#aFUCQ*jg~;R}SIWiv<L;xpC~BXdNUSprWZ%
z2_LB+rn*F^G83e1o;2Jh)k0$%l)n*T-tNDoJet0yysw(_mW8~`DS1?@(zi{CYl%l^
zBuceHVoQ~C@04EW-Z_awbj}D#9HoD@D8>+{zp!zd>Pg(ibW7sEiNr7l8WJ6S)C=k_
z`-NZo$(wg7*}OtuRn6vIu54b@vU#^Vo98Z0JFaosb2k?r5BCsyCALY_CALfSN$ilw
zxtEv*ZzJsF-Gp7dm#|x+Ut*8MUcN~FK8Y73UX&Q%dGZIjNf_c5VL#s>yd*I!aX{jr
z#LEU=P<Y6|?_`D>W~5<84OSs%L|!5)F(xrCaf}aAbX;PBPtiJQC~-0qh9^p9(qKQ3
zxnekG$XsohDZ}|W?WPT<P9|kIcF4@|FS42EQ1VZq9>8@cezXujgf_MhcS?B*&vSV5
z2Wacm_t74AhLn<D3DIlZhi@Mp`{1W2#u<w9gt7}gL$uB=qCcUAf<0pgG(e3}OVGmv
zme~s4Wd*#)O31N~agW(}pY33UJ;MjY&a*?TvY+vxd?y|_{$K|h2HlkIvYdpWe*pyE
Bcb)(M

literal 0
HcmV?d00001

diff --git a/DivideNConquer/Occurence.java b/DivideNConquer/Occurence.java
new file mode 100644
index 0000000..7718605
--- /dev/null
+++ b/DivideNConquer/Occurence.java
@@ -0,0 +1,94 @@
+import java.io.*;
+import java.util.*;
+class Occurence
+{
+    static void sort(int arr[])
+    {
+        int n=arr.length;
+        for(int i=1;i<n;i++)
+        {
+            int key=arr[i];
+            int j=i-1;
+            while(j>=0 && arr[j]>key)
+            {
+                //move elements greater than key to one space ahead to make space for key
+                arr[j+1]=arr[j];
+                j--;
+            }
+            arr[j+1]=key;
+        }
+    }
+    public static int first(int arr[], int low, int high, int x, int n) 
+    { 
+        if (high >= low) { 
+            int mid = low + (high - low) / 2; 
+            if ((mid == 0 || x > arr[mid - 1]) && arr[mid] == x) 
+                return mid; 
+            else if (x > arr[mid]) 
+                return first(arr, (mid + 1), high, x, n); 
+            else
+                return first(arr, low, (mid - 1), x, n); 
+        } 
+        return -1; 
+    } 
+    public static int last(int arr[],int low,int high,int x,int n)
+    {
+        if(high>=low)
+        {
+            int mid=low+(high-low)/2;
+            if((mid==n-1||x<arr[mid+1])&&(arr[mid]==x))
+            {
+                return mid;
+            }
+            else if(arr[mid]>x)
+            {
+                return last(arr,low,mid-1,x,n);
+            }
+            else
+            {
+                return last(arr,mid+1,high,x,n);
+            }
+            
+        }
+        return -1;
+    }
+    public static void main(String args[])
+    {
+            try 
+            {
+                /*FileReader fr=new FileReader("input.txt");
+                int ch;
+                int arr[]=new int[100];
+                int i=0;
+                int d=0;int num;
+                while((ch=fr.read())!=-1)
+                {
+                    num=0;
+                    while((char)ch!=',')
+                    {
+                        d=Character.getNumericValue((char)ch);
+                        num=(num*10)+d;
+                        ch=fr.read();
+                        
+                    }
+                    arr[i]=num;
+                    i++;
+                }
+                if(ch==-1)
+                {
+                    fr.close();*/
+                    int arr[]={1,1,2,3,4,5,6,7,8,9,9,9,9,9,9,9,10,11,20,23,23,23,23,67,67,67,67,89,101,105,106,106,106,106,106,203,245,245,245,367,8,8,8,8,34,34,52,1067,2345,435,567,567,890,780,657,123};
+                    Scanner sc=new Scanner(System.in);
+                    int i=arr.length;
+                    sort(arr);
+                    int x=sc.nextInt();
+                    System.out.println("First Occurrence = " + first(arr, 0, i - 1, x, i)); 
+                    System.out.println("Last Occurrence = " + last(arr, 0, i - 1, x, i)); 
+                //}
+            }
+             catch (Exception e) 
+            {
+                System.out.println("Exception encountered");
+            }
+    }
+}
\ No newline at end of file
diff --git a/DivideNConquer/Pair.class b/DivideNConquer/Pair.class
new file mode 100644
index 0000000000000000000000000000000000000000..b52c4463bba742c6a249c7261bf8eb826c69350a
GIT binary patch
literal 367
zcmZurO-sX25S-1YiK(ge6IAfn=FlGMQM@QZKvYnQ9+UW}DK&+Vi2kQu1dHIoAK;G?
z=SA=!vh2>j*_nO&`Stz*-~ih`Y;-(WSkq<Q#fFPbfjlu|=Ci;#%!|A_64>21?u`W2
z@$60s!n3?k=k-IX%IhSZlCj3Bx)GS&9<BOuEAX#ob(yKtTnqe@y2|eRljJc8;9)C(
z12@1DT<R~AycD$ca4=1Z@!%qzsH|%Cjj+%2Y~E}zXlgq8h$hp655Y3KA?KP2qc=#j
zvw#upE?~Zp5(KOrE&`1fzx5a^jkQJmS+GYGD(vVL#{AdjG-SXU{wp>AN?Vk+X*aO?
E4GfJfOaK4?

literal 0
HcmV?d00001

diff --git a/DivideNConquer/Peak.class b/DivideNConquer/Peak.class
new file mode 100644
index 0000000000000000000000000000000000000000..eecd46c65bde2ab7033375a457e3b5d0766c1e4a
GIT binary patch
literal 909
zcmaKq-)qxQ6vw}}y=mH*ZE<VXZcR1*PCM5Q6knzy4uwKz3Y9_J%hDzr+1jLZsknbc
z@I^s<+>1VRqOw20ze&V%+d|ci1#-^e+;hKt&bjC3?{B97?qf}XioAkLSju1-1sR3{
zj(i$L;jajDRTxvjHC&f*L&i;p)WaYQ;>Qe0tF*<yHzLnxn5ze&|6<T>`Tdt}t3#Re
zZV-A6-#wtv+OE-8sxizoW4C><>Gmd7yz2%b!=kla-*;cT)s7qPRhw}?2=~^7ywZ#Y
z{kH!+5Rw@oR}pn8W-zPbGUjF6QgIu17;^s$JRJlb&+juV)k4pIV@A8CYxYRO>_tHs
zo57)}!a_-yvWgYlm9eU#f-1E&CfBB#c5B~n#|(d^nn#DR-=#@J13J*h9RyLeLHIE>
z;k(^+8kpPb`Ju<KYMs;Lnbd@uE*e&?bir{tj>dyx$XaI$Nnl|_|1S`O+!J^mn!0`-
z&=yQu36)j^NYYP(2E8vuMe>ZiR6YUwOaTppY-*HDAT6GQVo~~*)<z<~T`&rs)Y*B!
zb^Z=oS?AoVkga?~LFYy8eHbTqCdrh}k9GbYg=ys{%$BK^d&RFv9E<#pF$zgOF#=d7
z1c8x(j5V_Ni2oUJH|TVMPBP%XP+-}FL17m9gz<>3hz2(``G?{pHN|$gmbD#8o3ovi
zWIM8!vz@f|%67Drwqe&-P9J?i@;kV50%<-qguIe8xMvX85a}T@Lnza+jH$A;TRN@Q
SBAy_J8u>c%1h6=w&;0?73AtYY

literal 0
HcmV?d00001

diff --git a/DivideNConquer/Peak.java b/DivideNConquer/Peak.java
new file mode 100644
index 0000000..f35b5c3
--- /dev/null
+++ b/DivideNConquer/Peak.java
@@ -0,0 +1,25 @@
+import java.util.*;
+class Peak
+{
+    static int findPeak(int arr[],int l,int r,int n)
+    {
+     int mid=l+(r-l)/2;
+     if((mid==0||arr[mid-1]<arr[mid])&&(mid==n-1||arr[mid+1]<arr[mid]))   
+     {
+         return mid;
+     }
+     else if(mid>0 && arr[mid-1]>arr[mid])
+     {
+         return findPeak(arr,l,mid-1,n);
+     }
+     else
+        return findPeak(arr,mid+1,r,n);
+    }
+    public static void main(String[] args) 
+    { 
+        int arr[] = { 10, 20, 15, 2, 23, 90, 67}; 
+        int n = arr.length; 
+        System.out.println( 
+            "Index of a peak point is " + findPeak(arr, 0,n-1,n)); 
+    } 
+}
\ No newline at end of file
diff --git a/DivideNConquer/PowerOfN.class b/DivideNConquer/PowerOfN.class
new file mode 100644
index 0000000000000000000000000000000000000000..a5283c6dbb861d83055d3810a12dcbd5ab6296a6
GIT binary patch
literal 963
zcmaJ<S#J_i6#g!=!7x}_WU(ybKF|fNS{DirnwXH#CBZald>UX{2Zxyn4p#q4e*-V}
z0TN040sbiCxl>xKZJgztle2v1eCOU@zkmD$@C<boi^!{xQBZI@f+Fsy5O7z)J?^B4
zfcxD2K*2*5D)M1G;#%jT#6?-f3RV@YG00n%WBGLkK`-qyh;QAl$*|D09CK&bZ<~Yn
zM%yNj?77GEF-Ur&QED*6TE5Zwv~75^1hH>e4ns=+(CissjEZeIN0pX8u$-eRM^;<z
zaL_T|SsX34=N_Ab-NT)Ao~vOA2@NTv85V=$p>NrhR>yE0bD&^dLj{j{))R*Cd8vjC
zJk@9+&l%GHwtO?R?5;Urhz99J_ps>HG;HDp7cVuu!fORp4O^%&#OLL^?Vj23FS%OZ
zKKo{$A;kG5&)8XRrQvu(p9q>pzsiu&uMKeKierBD8xDcej%jm(J0yD!v`0Id1IdQx
znNF8sZH9Phkymy*BT5tG^hW7F;jr(Xod&~A{c0isB!Vpvv%dzS={-K4&8c5E&^}!>
znJy%M1p4VDK^@4-lV+r)@&xQV8H7Mm4xAyf=)B41sa;4x@kZ_hk~qpq-U*WBY)-Pr
z2%YPXqwIxwVT`Cc6yT-^gQJTGlT@M6TR<Ec@`?z_X+&@f%d?I>%I5j?DTISlh!aT7
zDdd9*l<k!<!gVe-#ZyG4P{|uz(#D9b=93~#G{%iF7RHFrSuImf&>T@>l^|XjdJELA
L7Ie%~EQH)2c8tug

literal 0
HcmV?d00001

diff --git a/DivideNConquer/PowerOfN.java b/DivideNConquer/PowerOfN.java
new file mode 100644
index 0000000..ef0df57
--- /dev/null
+++ b/DivideNConquer/PowerOfN.java
@@ -0,0 +1,27 @@
+import java.util.*;
+class PowerOfN
+{
+    int powpow(int x,int y)
+    {
+        if(y==0)
+        {
+            return 1;
+        }
+        else if(y%2==0)
+        {
+            return powpow(x,y/2)*powpow(x,y/2);
+        }
+        else
+        {
+            return x*powpow(x,y/2)*powpow(x,y/2);
+        }
+    }
+    public static void main(String args[])
+    {
+        Scanner sc=new Scanner(System.in);
+        PowerOfN p=new PowerOfN();
+        int x=sc.nextInt();
+        int y=sc.nextInt();
+        System.out.println("Power of n="+p.powpow(x,y));
+    }
+}
\ No newline at end of file
diff --git a/DivideNConquer/Prefix.class b/DivideNConquer/Prefix.class
new file mode 100644
index 0000000000000000000000000000000000000000..d39a2e6d2537af20f84c34bbb447108465a495e9
GIT binary patch
literal 1838
zcmaJ?T~ixX7=8}fj}Vpufq-d}8WCs`z6#c~rY*H#Yf-)|h)r9SC0Sr=vdM&vLoapu
zC%n=bo#7UH5jrx~J1_h%{s3=^&)KC?nv9v<ch7mxc|V@#eb32XFMoRh;4-#DNMI_6
z=@1OOC&gtQ?}wmbN{Xx$SERTaLL47Rk<)Qa$Mqm?gwTl@9XEA+7(x$jh0u*zDdwc3
zkAk=@zjxa4G42L2AHpa2G>8Qqi#nDBwClEGyE6iTRC--NnX42nfvyGHv6kxPO{=zM
zZkDL&EL6(ninCI)w(PxWfvc&7$L6=@WXW{4Cs*B??QCCb)})(NbhYZ5g>M$ks^^+O
z1dP|c3#3yIn+@mZTY6K<rtJvyw=zku>sTgDq(>lhd#_+sUAyA!>R91?wNkGYtUI=Z
z*Wm-3keCcyz}o_3?K9jnu!=Q-fj7a<*6mW!su}nk>r#AS;6CyOMsU%<Al?<|e$#|7
zJ(XRV^n<qBPPOh%xO=V)`G6o^t<ToCwyc^}yl0sVA`pJHAPs$`G<hh+BLiQ`$Y0@W
z0g*JY0aM4OfdYyGiM1UoS*keO)~=iMSx#2HA|~zKqz=o#mJA)`zM3U<PUY-A_J~i;
z8A!{UkFA0$(A%O?)ShDhk9GPfS<be*<MrA+r-dD}c8flg)O>o5bF*5t9OgXUqPLoB
ze^LQ<PdqjEf6GC);y0*3U#fW{9Yk6M<Z0+R(VtZ8nmi%Br#in7o;FxxrR1TJuqsZ$
zB&?BEUYq+`K;5mDY#Ll_Wzdq}*L&;9u4|RaX{AmV5#K)(Ug42+iQ6*EMCcdftXe>?
z%1tE)NnR-l-bH}Im+cQh9jIeV@vCMIA%5jR;2lcMQ??-}JDuYsb<Yrh&hLY8+hV4H
zz|1H`RtaR)Kvs*W38nZmZbr0-A_v(_L~TGBjcAlVLfgmC5!C!4w6O+sf3bmJ1MQ1X
zRq<34`^SHb9ngE57k>op9BW?0AhS5f`7k<om3HC^y0FaoeO`t`+;tv-WAs7SG3-Br
zKVa}5W*wBr^(6l)y=mM(9gF|O6k^i{@z^gIj>Tg|wX`vli6x#Rlv6SZWg{*}YE+4;
z&(U!pPV*Y1M<BwRdVm>3nO6+`r1k=dOi^B9Oqr8{wswgjg)|W*Noyx<B&P4Xi@(EI
zI6`MWeC`lki%00rAE75dc8KsHdY8g&Id!~&zI;yk6J1ee(Lf}p?jQdhRm1%a4CJ(^
z_9ClCwLnByiZat+ltc!8K=K*hI$=2+CCyT;li~)>@1ui@;TVUq%0A0kvI*8#W6s^=
zH%YFBnDYcO$YBg~7{^`C)`;s7rtpOPe}}Ax@CKA)4m2GZ?-|u;K>mSa@^eP*R|R+}
V|Hd-Hn~pQE!op1Oo%9mA^e>H!l3xG-

literal 0
HcmV?d00001

diff --git a/DivideNConquer/Prefix.java b/DivideNConquer/Prefix.java
new file mode 100644
index 0000000..72e2d11
--- /dev/null
+++ b/DivideNConquer/Prefix.java
@@ -0,0 +1,55 @@
+import java.io.*;
+class Prefix
+{
+    static String commonPrefix2(String s1,String s2)
+    {
+        String res="";
+        int n1=s1.length();
+        int n2=s2.length();
+        for(int i=0,j=0;i<=n1-1 && j<=n2-1;i++,j++)
+        {
+            if(s1.charAt(i)!=s2.charAt(j))
+            {
+                break;
+            }
+            res=res+s1.charAt(i);
+        }
+        return res;
+    }
+    static String commonPrefix(String arr[],int low,int high)
+    {
+        if(low==high)
+        {
+            return arr[low];
+        }
+        if(high>low)
+        {
+            int mid=low+(high-low)/2;
+            String str1=commonPrefix(arr,low,mid);
+            String str2=commonPrefix(arr,mid+1,high);
+            return commonPrefix2(str1,str2);
+        }
+        return null;
+    }
+    public static void main(String[] args)throws Exception{ 
+        String arr[] = new String[100]; 
+        File f=new File("input.txt");
+        BufferedReader br = new BufferedReader(new FileReader(f));
+        String st; 
+        String s2="";
+        while ((st = br.readLine()) != null) 
+           {
+               s2=s2.concat(st);
+           }
+        String words[]=s2.split(" ");
+        int n=words.length;
+        String ans = commonPrefix(words, 0, n - 1); 
+  
+        if (ans.length() != 0) { 
+            System.out.println("The longest common prefix is "
+                    + ans); 
+        } else { 
+            System.out.println("There is no common prefix"); 
+        } 
+    } 
+}
\ No newline at end of file
diff --git a/DivideNConquer/SRoot.class b/DivideNConquer/SRoot.class
new file mode 100644
index 0000000000000000000000000000000000000000..5b5eeefd389584b9d89027e5a796484d9408652e
GIT binary patch
literal 757
zcmZva+iDY06o&tuIi=(DlsIXdgI1f`q*dcZ?M)5{r9vQ9aik#Lbdn5pYBCezMD%Su
zAic?ry=X<j2M~NAk?OyvN_ruinYCDZ?SFl1?fw1i%Qpa<xMjjb#=yc97O`X^fvo)H
zOiUp!V+9jeaMi%FfolSK%@6#jA)u7Xdjjfq*!2WvTYli}j{0qH_{44Z7*U5|7}1oP
z<)*;26S<ui58T1O-M;Gw0-4gY)}i~#t@PaBpyEVBKRBpLS<?we!;W{~mr|zlm|C}G
zqJ>Ma1m@#IqsZ@7oQ@j=-q65x3o9tfgjEYSux4Qva~4V{8(6onftvzatRyfuDf+N|
z=yeEsA>_Py8F_tyghaH@0sXMj3<jf!jGo)C3M`iXyCLC?z<V7v1B!A+Y+eaR^d~}(
z*ycni9kWpXLYNu@nbaeIoZudoc^fA03sCrR2;flZ6=(&mwtfoniH^Vw|9TuuASs7H
zU#5QKQH^#dtA2o%9V@kLU1{WV@35K6=ek;Ne@nHwo@d`ex7G2v{~j~8s_xfpwQ+<b
z-ERHp_m9GuLW#K4RxGYlIthbZ(_AT*&9QKi-Wo3B4l=ll1ymWmN9Jw5sCg=+pc`k<
zgb=^5B+@^jCfH{R>A%Q3L{^zs_=?2SV<@LkTN@|P>iN&m8^<sTCrD1Z&cyw#a6Cm8
QUxm$gkSBm3g2c7|0K+ee-v9sr

literal 0
HcmV?d00001

diff --git a/DivideNConquer/SRoot.java b/DivideNConquer/SRoot.java
new file mode 100644
index 0000000..3d45b59
--- /dev/null
+++ b/DivideNConquer/SRoot.java
@@ -0,0 +1,40 @@
+import java.util.*;
+class SRoot
+{
+    static int root(int x)
+    {
+        if(x<=1)
+        {
+            return x;
+        }
+        else
+        {
+            int start=0,end=x,ans=0;
+            while(end>=start)
+            {
+                int mid=start+(end-start)/2;
+                if(mid*mid==x)
+                {
+                    return mid;
+                }
+                else if(mid*mid<x)
+                {
+                    start=mid+1;
+                    ans=mid;
+                }
+                else
+                {
+                    end=mid-1;
+                }
+            }
+            return ans;
+        }
+    }
+    public static void main(String args[])
+    {
+        Scanner sc=new Scanner(System.in);
+        int x=sc.nextInt();
+        int r=root(x);
+        System.out.println(r);
+    }
+}
\ No newline at end of file
diff --git a/DivideNConquer/SumSub.class b/DivideNConquer/SumSub.class
new file mode 100644
index 0000000000000000000000000000000000000000..3f68bb4f7b549f0a12ee0f6b6b9c28781073eb3d
GIT binary patch
literal 1216
zcmaJ>+fEZv6kW%;oH7hBqJu(PE-KI#0k8D}k|@!H1gx=!q%kH8Fu}oINIPRRzWCsW
zXf*M~7kxmZ#t-lheD*IiqU+2wsYc_pv-df>>+HSuI_LEB-uq7g&ft;-2g4F0+GEZw
zjAG0}AC4$<v<t^DE-_&th2az?mCq@YSEgWL3dbd;C1wQ7`Jf(z3j$g$zbc?FHa2~M
zzU83qUyo|*e)E>MUS*`W<~>+!Hd?KqzEzHD0;$~XB|iBjfu3^cZQNV&c7DT_qxH+p
zruQ($${4Gldd&;!0t30*%iG?4Z?@{yw`R*>lUe6feXHDvnj8MLK-KK#V&<7qNE`dn
zFR;I}YN;OjTYghw*2W2(v~d`NHe3uyoU(BmX9Ny)&`FIeQBd9Vn*u{C-h-eP)kZfO
z^)T3q8c}Ps#c9wQwQ&|jWzN|+j|&nPZOmbwQYCZ*oKD)(`nJCjQl3s|#S8CJPU<CK
z<PwE`TTy=43VrIQH6pHa6B&ZW><wxVlBMs}=2*+y+41X}0@JyF2=!N}-4_>Ta!dLD
z{G19Ki4p<_bAJPw;6U8TpM(VDj-prP*17*8w8{h6#}la@oiFzaOvO=_UeFtbw-B#6
zU}0J_4)PSK4dYlrzd++0*w%`Azg9FdMbkCY&yaQXf@{vK6?Ip4jTexvUNoMVKVSa*
znjp=LzE+g3%sx-BvW+zptocL=VqL>E+c{kG9dv$QvD&_v&y|?GK?WuyKMuMu7~iXI
zUM7hGdN7S%oMfBxZ0{-?Tqf%qoUgKnJM7{Rv$-($U<n}xzrpx{?qtBWcsSc_-h~ls
zG?mUgg)F3JUZpc@Ms=Z(&c35eS$!=-Pj(D&q^Ndy9*GqiVu}nI4zv0QhA4iP{ustE
zNw0Wl5M2ZeA>FR}h&9#Dl%3Q^tD-r3rHbx+FI5c3ELBW3mClb+C8d`tj+vs7&bQL?
z)Tc{RT1MX_p@lb)ACRiNMOVMIi|*_$>|ONiqPMfF1LOsaQ>h7F$w^#59yj@K!(++#
HK4gCZ1XA-V

literal 0
HcmV?d00001

diff --git a/DivideNConquer/SumSub.java b/DivideNConquer/SumSub.java
new file mode 100644
index 0000000..c9786ef
--- /dev/null
+++ b/DivideNConquer/SumSub.java
@@ -0,0 +1,44 @@
+class SumSub
+{
+    static int maxCrossingSum(int arr[], int l,int m, int h) 
+    {
+        int sum=0;
+        int left_sum=Integer.MIN_VALUE;
+        for (int i = m; i >= l; i--) 
+        { 
+            sum = sum + arr[i]; 
+            if (sum > left_sum) 
+            left_sum = sum; 
+        } //max sum from mid to left
+        sum = 0; 
+        int right_sum = Integer.MIN_VALUE; 
+        for (int i = m + 1; i <= h; i++) 
+        { 
+            sum = sum + arr[i]; 
+            if (sum > right_sum) 
+            right_sum = sum; 
+        } 
+        sum=left_sum+right_sum;
+        return Math.max(sum,Math.max(left_sum, right_sum));
+    }
+    static int maxSubArraySum(int arr[], int l,int h)
+    {
+        if(l==h)
+        {
+            return arr[l];
+        }
+        int m=(l+h)/2;
+        return Math.max(Math.max(maxSubArraySum(arr, l, m), 
+                    maxSubArraySum(arr, m+1, h)), 
+                    maxCrossingSum(arr, l, m, h)); 
+    }
+    public static void main(String[] args) 
+    { 
+    int arr[] = {-2, -5, 6, -2, -3, 1, 5, -6}; 
+    int n = arr.length; 
+    int max_sum = maxSubArraySum(arr, 0, n-1); 
+      
+    System.out.println("Maximum contiguous sum is "+ 
+                                         max_sum); 
+    } 
+}
\ No newline at end of file
diff --git a/DivideNConquer/input.txt b/DivideNConquer/input.txt
new file mode 100644
index 0000000..57ec0f3
--- /dev/null
+++ b/DivideNConquer/input.txt
@@ -0,0 +1,2 @@
+appraisal appearance approach apple application append appendages appendix
+apple appointed appreciate apply appease 
\ No newline at end of file
diff --git a/DivideNConquer/num.txt b/DivideNConquer/num.txt
new file mode 100644
index 0000000..f3d3d23
--- /dev/null
+++ b/DivideNConquer/num.txt
@@ -0,0 +1,2 @@
+1,4,67,89,42,35,46,78,98,134,234,567,789,234,9000,568,555,10,7,15,32,
+52,64,31,97,160,543,239
\ No newline at end of file