From 95060090cf06e274573226aad2599d6bfcfbaf02 Mon Sep 17 00:00:00 2001 From: ajay-dhangar <99037494+ajay-dhangar@users.noreply.github.com> Date: Sun, 27 Oct 2024 10:00:52 +0000 Subject: [PATCH 1/5] update contributors list in README --- README.md | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/README.md b/README.md index a9ed42790..c57bffbdc 100644 --- a/README.md +++ b/README.md @@ -517,17 +517,17 @@ Thanks to these amazing people who have contributed to the **Algo** project:
zY3;*w`O|WPJva+5jUCR<6?q6HKntf&F2dQ_Hdtg^E6g2dQ{Ne6L`Xp7?6a;D6wr zd<4;nA~*br5c{wsKASwW1*)Zfu4owf&fR419>n|}Xc?TgJr&<-+v;&*XV+YJ24b>D zQeUeI9}+doCFJFi@(T(CNCXqI$W=_3x?c=CCvrV&j3z&4Bp0uR22-y xzVSmwqFv+$pa+^-UoK1jWo3e=^~n9lb;KQ8bg6Ec~h !m z-`EjYI*~OrZZ7xNJyQ+sBpqfsnwUHZS?gFA$M|YW4|RRM=|m3)=rUV8_Tru$p!zqD zIuBTScjbB#SL!yR%oHmP9?z8v#F)S+@a8Z!jAUfS>M=gt!o;uhy}!R_E7KrX3fU|& zyIicVvAuaHfg7yvlJ$W`yuGKuOK7kj%*bA9k$g)r*yOn5XF8drXl&gbnAvG$XNi0Z zSlB!+yuz)xLowW;?M+`p-TswHM5eqRD-`#P$e4m+nT^g)weti(&8>3f$= qPJ5N z-l*F!)_m5$&BY>BbKtwF@p&NkI0K@jixzKJ^%8gEj$M&D=>f}LAPfm#5s7)t2f6}< zOzcF-5;=z5FxcblX#gr2lp!NcP28(~FK5~ItXdV?fsGq}1V5>iBvTmm`AI(`-^0$I z%Sc{@E?!7V$X?)azoRAXl{U1Q(u97@;p6_&T+|yYaelw<$+UAP$CuAwalZ-Dp2Q6j zEPXKXx~4dEB$JM$w&V+_7_cG~!H0l+CKI#7d9b*_=EGcu3XXb)D<*0kxmLDl^dfWc z?oP%7)XNM`v=VYVd@&!-JmNv;b3fO6J$LWy-AgfyjgCeVmz4Bs8M9)?pLiXNGyjC6 zZ@i`LU&3U!gf-SsAD=hb9^VFJnzq8M9nT)}E7F6dP^x-iYUQA0sq};{K91~!CEj#= zYA+@pwInF$^R!Hj#D!cIUc|grb^DH}MPdr@Vi;Cx_&&a^zU?S9U4;>}?@_M)J(uD4 z_aLX$S7hhZ>fLq%#W;X0#KAb7SR%f8=YNSf1|H!4uRA1;8@>-)$+~t|vvT_1K~5xB zvmB2e#9JJmHWLMu!z>N1cXi%R3`q62IxPN?N;O1Rg_uboP7PJ$C5PDUbPCODMcMnU z_o|!-+bXTbFy^f?s~TukT ~l`py)@!k9@`A8zgGdtP|%M1+J}ezKcGAht(aPNY9VA2h-Qbt84&C(2pOu z|9Lb2eYeIgvyC9E!H&LZE4Ivcaz}+>{U)v*aQ;aRTKApb;p&ARjQUQzPC)hu>F5?@ zcS>Z*BugSrEWbF{`u-BWqswAFDEUfx_`C&EuZ3@^uIa37ro849t|HNrLG!hI zE3lyOtmR9r;e*pqJZZMdPPWH3eB1r9wa4>Ou|NTv9M!`Ot1!qL?poV5;>9LcE=~eP zi_U40BAW5s`%op7Ov%t+^8rOFU8E2NOEmkx_U-jgzmiJBwO~Hn`r`W^KKVB>&ISxe zUR>FBdwow&H-2EuRqiJhH4~0sfeF!#1?$8t#8*>F!W5&=ca=QE^n;r|%uD>|DgF}_ zLs956ZdUof(P{qCi?GP?op)Y0^YGw?y#t}yeCLrf>vaC~wUf}{FOl$h7~wsC2I6B+21fXbzLuVTkDVb- zOz+moVfCX!4BQCDzi%Za`XLtt1pE&a$WY(ibtY}b2kv_wE+0-kAAje;D|B+>-EI$H z69M$mruSqDPyVrLgKQn-l7F7$&7+Dk#Sn)s_b=+yp&2Hdn^^SIR*ZV$qn>HU;WuJr zL7bJ;5%!>(eH&s)o7{fhJFHdBWDQ-5;ll_usc>TZ8@a#z)T6rChuKJv)V@8C?=Mb& zY?ZvTH>R{%`O2ZKRs*m`IM_NnJ-C`3N3F@v$F&QYCAKnbZ(8gj&qowRNS)pkQeDt? zivxua`8N`jGh)Awg9utze~k35mXtoj*`Gc_5^vnWtTVEa(%x&z%eNwGg}F;KnW1tL zc@Z;Vr{vF?50 FF!r3Cis0cW`5*?e4hVADQ@0EZ)X+-+yBJ=R{pzw@ugu#I#m{zK2`9k zXvE+#>P%|kmU)Nx?tJIxSKP!$UL?P%HUdu2?Yod=xOS5Jrf`V`09=Ivp+a|_2>#Mp z0W2aS%(Rg4gnZC5-a>(}GXr0a9)|>2v5?*&9b|@kA3L+-wi0$pr8Q}ClmC6u>d$q4 z#A>4PrF^e?32LIc!(OGGceEa6U!B|Y8$D*lYaF a&5vsSE*`FtO|`1O>2f?AD^GnL#oHZ3Sb+{v03bo>|H76^>sO2q%xx0F zZB+dzLMP`J8rCQzhbUW2AtkQ2e1>h$#HD^Vs$Xsmwtum&GI{!)&8;ma(x_Q2PMqi0 z*DV;M5baV3SkpYtL1%5nzttZPoLQzP^Oe1~M>92EcUIz3Qevg*Ud3ox-v66e$M!`- zQ$MtSgK?nZ#e%fKkbZag{-!;>_f+^SPY0?9Mx<0r^f! NNUM=lktw0MJQBuqO z6_+XkonjOQ@)Po;)S hw-W&t1$5%2_JH}ru>={T?`FrU#a=o0)4 zcmD6wa#3;awPO%AUNf&?(0>_GZ9q90ZZz^%K#8qq@7{HZq-a}ZY|=AVpR? E?!d!yFRX8RLu@~O_r>CEp~0mGI`fY^4gzxzqrW}vui}g*2Nmee;{wQ z!r%<|U1`Z#F!p`YtcgS2Dk()7Ga=z)nluFw9#(W9Umeb9rN}<(6AayI-$k*ZA2~Hr z)rCd(r|;LgQ-9=D>Sb?bYRj4DYb`V4%cw$i)9QNlQE;zHuq&T^PqfCv&QouB!ojUP zcbE;(YCQrggQ 1~ke((=hT>0|I|0=lMi)lJ*B zf2jOhY{<(;uoUNdxV4t-i`Mdn*48nJeQ%wue{Xp+LA-65M9>In59JIcC^_QPthZhJ z54?QtxqR=DpEKjEZl=i6?j5;f^K%r-@I}0Yjxrx%uwH_JRNg`nR9*s+A0tgfToQe~ z8uf4_Hl4^y2OvL4$u{n-`7(w%SwfzG&j-K57b6+!5BF-eE^`n=ki74z-Si+cs`udi zx_1cky}8v$dYh=JcEq=d>y1(m4;{v}7u_dY0FtZnBLnWvJK?~HJS_ashJ%B{c%#Et zyAC*2mE0SKYWi@#rrqqcXIV_b?GPYRiyR+86*$r3`PXiZS3XCOs9dW`(#3^6Nw&xx zVXApyax$PuF2&^jbZKaG^mcx_e b)zH9YXGbD$jH2d5@&If|Szf)G`S z_VnxK>M^#T`Z^<2%4;JCF9HuPl!)_%g GG1H !-xNrD! zQ7WWErJc6 Q^ZTWc7OGxl2Pt zvjVpDT!&~L(Fo*Wg2RwOY^5Dsirj`!%j9Yu5rJH?k;=LW{pbhwNR*bb#1khWyY8kY zOqWtokfPspSQBD$GUTFK4TK@l3k2eI2VkV4>o{F6iMMW&`VCN+7`0%Mr+px$Z7L&v z@yK$BhZ|*7qnJ{T$9Y5P P5?)CKt{NI8bRR+G#RRQm^V8{=wA0 zqZ>>iaZ=qv3u|_6glj{0<@&Dm_@@KUT!Bn=c6tLyAS<`tCDlw iVG2Gyi_+pb2>oSmDtsw@2|1bU{m zaN9eI5+^IPGSonWQCcw!6fED!qGq~Fv34v+QkhGfhskHmh=YNoh<1vLox9Z->bX1N zBw1wt3Gqg_8)VR75{hL)gm{x|B(udz&-5+qZjNWDmKKnYiZxMBD9gDlJv2Nl>gy|j zj*cFmlmyBwT_e*F${OFaKdg&=(nt3bQM12UGRCqOwkC>;3JZ-MFSkG((Zf2qKD9ir zxcFH%1VRWn@6}di5{<-Vd?QTNj1{tv<_sl0&$HmVz+bc|Sx#e%GjPI+2~o|b#>d-9 zZx5yiSep_CksvvQqRRgHzZfS7LcOo#h}F43fd bfn%IwLNY(Qk}m8IvCet z_3M|0{^*2Z4GMN?L0@benlz(Eav8VwlVUqY`e-urEJ+dqS;@J-;|_e)3nhi|2ljRF zn~_Amm8l1R;q)Q1i?|46EMq0C9Kl{uL2k8(Dnfe%VDI`wnC 85 j$zgQ(tlJU{A~^2C+&uDpZE=b zWW?PlMSHL#T|wLM7Hgl#i{t{!d &pdE$(`Ifo|Ik>=V$O4 zE?b}Au^wX@O^6ZDbIJ%%7q8)|tmej_0@8@v-I){q{g=n#CKB!c6~dpxQWlaKb5puo z?s28VzPf)MUI5*EJHl^b>#4)PZ$_UoH_8+vd2h7)^+(L2^)DE`c=Q-NXbR`c`#`2E zg?4=Snwcx<3yaGG!MLq+X>uD4k{xG&un--SNR+z*Rk&Hk=u36|Ci$!H1n=xqT< JbsGYvXY4Ks%ZSurhYjLEe9u!S96nN??RBKghL zd`)jPj6sm)T26oM+efI-Llfiz^uH Hh^oUjybim{#UiO3+teh2s3fVnHEhx=vEm;82GW6xR^=fb2AC)H6 zKq#4>a%;K#ufI+ifl-rVkxfTbIi&F%s$7Yv>^C%ug+uVp0^nvcLqUpd`}qnJxw9RQ zg;hIjxKlg-HZ@sx89j9(XN)@x6WmJKoK70Nda(1IRBOjc<5;;8( @0A8bfdM3K8Hh^j6hh<<8eI2e{@aJpm$2A8_e^PY|^-| zBY)w_^aox^GWvQ!FkgqHO}+w;%x2*0dd!t0IWzYci0) bNh(MTAe; z%&SO0DWrnef=Zn4x)uI4ZgtGUH_=;RN>a#o{|w6RMoR;Tpd2WXss_6?7QhWwaI#Zl z07_yc`z(VlO4*;!!!<)lXAKao Dmx#fhdQ42=8W?0drpo0tYJ)rbTjD_6= zEVN%?5D75gpOPC?dXMqinvdSk8Rq_v?Z9o}OQRKm=D~$zkRAOy_oY%3*AqfC3Q2&- z6xU|*?aO6cwE82LUvw2++?NrXD@GY{mviaj)EGRr{fZ!SCnwhJot>= sbeSt@lY32E(TI`+ z4EX`kA8;I?r{7Ef#r!;aGyrT~7{_$!#dNE9Lqn9PR%p8uy9)cdJk=Fcz`JF*kf$)I zhT-b^2c!?nxoz9b8@hOwi@Ti#xEto^;A@bfY3IGwt6ASn6X(}uzSJrI0xSw5v1sFP zWugtrBVaMUWT)`Zo*g?65wl#1vm-~3%~&@|!q3rA<8Z7MEJq(OvNXw8lHhW(poBsp zPjxaJy>UtHHAe0|uM$ih;P|d_gy$Usg-dnM5xaLw#(Q!>0OJbycMi>+06KV>9i#8m zXAUhD)y+2fi+PijU)UYc$THnd8Arro>Y*(NIM(ic2-&cVGbo@Ub4RAcP9 aqh{aVp-6Z?E-xJ}>|OHyds4}| z!kO$`bZ6 918A73!`X(GA4HtfrBAM2JX;-PlW7JP2XQUKOO2ydZ3 z9FQOe$)cV`fEyL&u$H)Hp%q>REmQ8-&qsW*2 lw-=w3hLuCD#CAkKg$WJHmV2DS|8!I dd9_a zDmqAZ8C9dT(?YblS5*%m(>(6oDn^gnXhlhL882H65ALFd3LkvH;Mq0d(=cgSH4E&e zfmlrYD%psvS&YG1(toW}lRYox+K_oqrp}kHyzm$D<%VQXVPw!`^>0m+&5~JubU&65 zf568|Euk4BEPgue)OKCg{p-R<-%*KpdpkbXyl86Kd+1R)C>)`xG+iBDahyqxbL=w~ z%W6iU%y_Ekr3VEDi7=x{5c?%61>>~bvO!=nTS?0>AT}o7O|*!ejPsaRZ|z8OHTCPS z3`gf{+a`uP#nB-&aQ4-Z-_I0}Z5|kYB`Ga!?};mC!6UW+QknR2MLvgkz25*4W$=*M zdi7w!lof{LT4^GnL_T_+{3~C9(H^6irY-z+dWLvcrKGJs<-PV9Fd yAI;G4Xpq{l|(_oh(ns=QU=6Ou$RHC7yBrG6eQy@ *q5s^ZrVeVyQmLIEro{m$N8#PZT2 z`I0XLg0uZMRP$s+H5yhkQ*SsYxZ&>r3}yyXY;%e`iB7N}s&x!N7V0#G%lKDdnL6zR zm?$X7KjmBr{bY~pF`Sz5{aU#Do~XV|#UIjSL8vBRuc8K-{23(r2boYtJ-A->wy2}! zyv!KS3Sj)@ wT@ zx>O!K#x-eMnB7m@X&yeTW)NObkED9ZVWwlvLw0sor*SiayhkjpmDE*Bk?3;JtIx`P zxEN?(pcPn}Ijm(#pAY1s-pJ=qFkha(JJl%Fv)03PU4 XS`r(kIq%9&|*|Qd291OD5Kys)-9=i zj>JrsVCG6^DjZO zCLp<}plN+cr+L#U! AgPf$3FoJ4KX?CIs+DgGx#NMw DiRu7Dhdv7 zZm4`U5* cY9yjH{ixSg+1P9iwD=Bw zx!}@Ws5k|eSlL@FCDfG>mSUo@6sP^`fiZjOmfr23JW%t^sfxNT1%#?H9M$y5PF>}$ z*7xC?>~>~6wkD|_`9G}b1@FQ4zY9f%%^Qa4)@tsQm~d0NHe=18zkHdUG1Oc(68aiO zMJlZocG^<;n9q#(l*~Jufoe3Chf`C+N$|}sr1;@1;?MA3=G#buD3Phs>iMdHk&K)! z-9b%bjVH+pn#{1q+ML0im5u($NRuWkCjjs+93@gr9ZcC|xX)XPi+oTo%<2a4egBQX zFom&KXJP@-4&c=8sc9~*`e>w=$c}CtYtvT$gz7 O3E!`CpZT&wr5@wSR>OFxWxC7zAcaUkngM^iB>c z@qSD|7nh^(K$DmR{R_CP?#9JmB1(`Ic)eYl>NkW>yMsef|I z|L62YS7DQ%^ujU7#|D%HD5m`Q+Aj2}Pr $~$l4!sZGz6ewr!^-h(Qx=ZTs8lvi=P{0a3`7 zu8nUI!vpO@^oBw8dn+}i-O*i_G) ?hB8T77UxGmV_u-&r|s)49LG{?3o; zhHI__lR9?$Qtm{@>3M%6X;Vcf9>T8@ym#c$bfUhBIRk0Q>kr&pho$KGt%!qMxe`3^ zTVPS|nkX5Ie&9#G0=4?BWX_k$@O FgP T+Fa?{ zL>fW~lLg_OXDv*>%}&d0Q^c*=2B&KS(nShj9)(gv$!@eZ6XnlFfHfnvW}Hppz2tfW zVbGNW3;LsK*0AI3ro{SQ^OWldyYv3eEdnF@N)!tc%20!I9`c&>DYY{?dsECb9H5b; zJ~olQ1N$~~YuX*S3QFAQ{+=Kz16jH$XGAMw#Sh{G!~ZmsC=o42lLtN+={!(fIaIr3 zjqj{F@DM0lj1O)-i*eK6%LJJ*Y3^4J%){XH^j7uNG44$1LM>$v0HJ8+D#2gB|DjCc zI_(a8?j2&`>N>_IVBq?~SuNCZWTirW{t`feCX=9L6l`#W>|)1F$Wg*UB%(PcvfIF3 zpY2UEBU}}WJ|Thc1(FKasiHKqcdkV9&ZrQUt_4;6wyKlP0Lgn&{kaOCXf_W<`;YP2 zOib U77I_}T5^BrwAuB%&P?*v(V1u*|NOz``u)E= za)*Vua%n5sRP+6kMb1`Hiovzdzboe;SkwW!s Tb+y8obfU&Pc=C?j@jRfz`IP@vD1p5|(G5!ZQU3eTs z{=~O@(etJJ;0cb=%b-*)??$29NQQk!M4aIBknW6Z@r-d#FnlVT1 fKicYNHLEW` zDJWMk)yWD8%OgGy@)xr S`c`CKh9tcPsHghK4IOVjGga*bAw?FAPZ> zE4ixaK(3ODKXr!NRt8br=2KA4&d3j}MQTx-nw`FCL2>b0Avk2@yWp|vYG!+d@}wlp z+w--R7lL|@&tjojQtBj9xF}yh)qM+rI}Arb?jiE4=Sr^!^$k{=zNxTPPtIlIdE<7& z5b&^V c=9%+u{NGj5phr<4aIOS-VHESv%s zsaTfUnoNEL2?T{<(kzq tE@t{+o~)egIzS6&k<4*DMGWWUPT z-W`(uA;WQ?3_eC5T#X-^X|wLr(YM_)@F#HN`qqE6zko_;vhYAfH3!fnI9OPF@aYK& z3G4Wu`OJv$lA!p|LlxoT7^&i1KU`cM^n!dTWA$0-=;*^JV( E<-mN%e9ie+^*E Fhl=AmyFc?cr84LskY&R)LHy&S$a`bk%!KPmPvWbu7==Y9eHU1dHo5pQ`@< z01o9<5UK(D=npB=HU}( S(qAL0VcGs8EC~zn0B@oqzY>z*`cGNWiPEF?qZZBr-D@&*aHI$S)`@FAvJeF$^Pw zD*=@$rE*wfgCw`P%5`T`V-wz!>=|QCck{XefzGFkHK4rl1vaBzINhHn2=`S-*zN7@ zwt5%A&+#QNF#{Wrqp%rztgG7hk7Q|mBbZ|PWY2UB42aV+GFXgzp!7WVe%T5Fa~^V+ zW@m%{{iG_e-{|l-E-eOawe_(~o*4}0BJ%YAq^EgvK9_R{2bX;%6dDnGvlmsUZ?)N3 zU?EYR_7`YM4Q!X|;OVsf+#-dt+b**M>vb-Y8X^pR(f+dt|Ht$NSG?&i2A90)IO|s@ zKv^7j5JUnM&3r1We6Igdm6Vipfk+64qoNcq>m#2XS9ZSas59PlP?>@OGtj`pycX|s z67=2ILi+l||6A}?T3Oj&xMFwXlkIZysl_}X2r?h+&3!Ut2D-_Ea@*N6N4GwZSy@@g z3s1f)7$A0T+o?G|Gc&p`80zrO%bp?29x0s&HE7?zJ9mkN1vJm9J6&52pTYgqhd703 zjA-8FyCe?8|LUoqM%B@qyL6>zBl5Fg{QnH)h5oI`%--KFlPXZ9%cxwz8dTH@a^nhg zYXM-4Q-x5IoAKFtQEp{7bYv-*GGkFO40?V>k8 g z0xxf={!xH_T`hs%eDeE55x98@hT>F%3$LzG14r(Zd8j@+yV4AO`%t*=wv|X!J2>*a zc}*6Tz4FPsQ@AZ>#1Yj6Dvft)mYb4yD|teMk&{7V6R3{wQ%?xW(O%7}DS2A^w E3KS=Bf4VHI;5`Fpn8Y?B8cxO|ar1)wpj48vLBv$?ur2#AMA-QFFmL zU-Jk19sVtK-jmi2WzwU#(P=r>L~APS@pK5nXRSokCS~H%N)_Sx@o0RB3zf}cTwG6& z5VQfqXJ^$vmmH)N#74xX?*b{n!<(HC$XHp?Ws9l^YEV+;y%W-W>E4x1B=+!#5)z2T znC%GepnnI$KuXx}6a+<8D+ BoUiQ2R(FmWIIK|Ks)>p_xIXHOHeGT*Nm>BqLRvK zi(jWx=`OqCGDR{qdoq)N@5nJQXc$u7wl{nT;-_1c?Klfy@S4 9^Bz&HunA?awo(kx$% zo?nNhcTxdxNp4a^R%89toC~=UtES#S>z2&B5^EY!M>&eJEJpiEQ0kuKYA-M4@+FJJ zSfw5^B7w~Rt72DEyf8Pu*5;cp)6R#Re+ao^xLc!pjoW!XYP#RMz$Du_io8;WU;b*E z7gi{AKe;dfrZd1Xm3}TO)sN3EoGA3%su?aF=T3{(qW`R+*VrHiS_<3fn=N9r2qZHn zFVS?(cx)}sr_mmc4oOTRiP_A4UtNA0&sknB Xn}*ppcZo z(l-$x> N@y@q5)oe! zYW7~?s$#R<*8rrBp*Lv5otm1$<#8%(yl+&ae%-8!5Ka<27LQQp*pj}pv#F{T1F!=o z+z0~2RY-Qyhy$4`0e((g-&yIL5ciG6$a9eoLk+qmXEmz^)34=E%l?VF`GU)yF;c5b zLeUm-MM3w2GSF%o;E|Pg)yuI)x<@cJr8FV3IN +f>M=WLZ~bC9GZ0|fy-e6b1OB?tQct~X%*@1iz~|EtOU85M|m35 zc}dBRt(z_!`7Oq<4O({CCyRku+wZ8HzY3OV!hW04bkJ4>^fE&P^}y!GX&w)32Gp97 zCu^nUBDP^-^dWXcm0@lqV+xb-U@e413VpSj<9XRPUixdsj2|;JG$br79sYSNhll$` zy}dk;^YIa2P|62%b_(q}88&Wz-xk!EEa?SJ37;-`*s33roKs`oxC8m`uW?<6;p}~$ zzojD4L&20X=0eNT?}jQCg9`qB*URPyYgoQpG^in3DRU<+KW9eCATZVnC6gw-W3S8m z }&Ui-Zsct9*xsS6*(iR(2ro*YZOTmj9kN4GrkYo-4-Yf-;eYIQ>; zX)#kd(k54W~1 zwrJRnmqFVQ>E?Ozma>H9pwkf1@Fqy;AX(r%DlUJi74>xDQ0Ih*lD-Rvm=i#wZ$G%$ zg*)*c$?}z4(;zf?e@y$EE~NV|do=b46wR)MZ*_4=30!k?Gczs{sHWzD=aBJC7sq#! zpQw?XgbyS~Qmce#j_zrfDa|H#FYb6N#5umowG2`?L-pS^)_+fVECV9Xr_lFuQDh`6 z%_4 gTE2sU$btS(#Q?WLyVZx@)EeT0)$rX{+hO zhB)rZh^Xa@0xvb1=w)Y*j#Z|ru?#WU{sX}DZN@=E7HBMonHyVrWOb*rx-)fDu;FdN zhv2uc$UgR%TxAgbhUNvuQ**aitgU(rsrkz%?iZQ(pNb)gB7PM87(l+hO?S-?o=5k4 zf=7#Q6!~*6ms5F4HEp-J73sJxC<2Xx+hKnh$oTELLnH4N zHMJtlJ<%Z8Mc_27B^GVZ3alE5d-i*jE@jRw9=ZJ~=EF1Nzcu5X3~QO1+QJX(`!OHp zqZLmHlP1^Hoem8AczRsOdwML{l(H!uN8fT{a?+J&{&v4*WC|{e=B+yE(p?EBs=Wzz zi)DKe2rfca=cUOIPH+#&JztHnG0Tev@WvS+aDh{4_{jD2Gf1$_YQ+wtTQHHh@?#HG z95j71>@)OM=+}5>oW*47!{I@!>E90(YYS0#!owVgAS@Z}OV;7yE#{9L^j7K?{`i91 zk2piy&U~}pCzh6Dl12dy`IDr-7SgbPr2V4j%-Cvozx~Izl>=i9eY|6V1Bn*n#=R}+ zDMSzE7exBT-$u&A7yYasT~WT~#$HYMA^lZ5Ro*F^FUPE@o0v@RVngG;Fmc3sQES71 zrmt@k9*&!}kET{ag{gvl< iYJ{5$bhu9poI3|5O=1tWwTqJZ#-m zG&%}9 mCMtb=T&cme Zc#dj-p z4lWUf9-x-Lz^w`21m|~y=u|HL<4xvU39oCzOP`bz2hUl!=reZ2&J%v59WjNHzr ;E#7rNPO&rJRpJ6 zecALcHSvns;20g=x3^VW+Y=X7=X85Kvzo`IgzaRK2S`YK>L+xr(2k-NKFCaa53{ k9z7~iGaxL1 zVA|)=y-dcYM~ke3zTQ0pI>XMcOdY !v?f;KiAaJT}J>b$xS?JI3Une^b;W5FiZdVd}2e&+dVoT4P?UL9OQ? zNZ6^49CXH|yM7?uz>IQqY}~xE<1*Fr5W0=QjpOrrgKiAH6-i&Av0cP-)OIscICAs( zh6VSrxx&IB9cE-E6`qEaZjdL gp|93j?+&~mgN+xd&Sh?bGKFfQ4gRY_q%gcA{jOT-}|3qscF z*rMUL08wXhLS^A%IkC>VgUk8q&Ykr|1L=jx7tA=3DkSl0M)0-Qq)TUwy!CZ@SqdxN zSflc9@L^X7w@A|BiStUMbo*K%q 3Fh7PUP`p4z-d;3qEjAegR>p;ydWV_vH{W*uYoLkWQKnpTEsX2FueRP)xXzoj z3)k=bT20hSJ@^oL=z3P%EHXxs#AVd_JBpz)#-K3_*ShdHZ?w3(558>ai~yC;FODBx zhvF>2?S%XXso*vMw)Zc%R!VN$r6J7jM)^5N_<`)hQdG1vC!#vp8lo1YTf|tYvd%wu zdGEBAx~tXc^V{W+7n?ynqKlABgX9ACqFP0I{A4g=C||)u%D(h@v?etO-Z_;dk$t88 zMP}4u%(n-Z2OvHE(q}zKHHO+mh*eUrkvFRoI}loRxj#O5)i=Mf^U?60L)|%8z-Q1U z6niTEYa|w5jUnBZfebjDrwrVxx(aJEqw?c^#?Rh(q9$H?Mk7Wac{M&5@#t)T-a|Pe zt5RIdiUHQ76s%ST4>O6heRG{86mtCbJ3#L|j@z`_gRMm8 % z6xYwu28lw6*Q?@7NLX1!x!p!IG-yJNC@bNpmBx7IXPsFEFKLGNx^-EthgYGt2Us+| z&5kDz|MX5V*7^xom~1|qb}TWOl&tx`baUqaP;Y-6=QhUJM`O!ABWu>1C1e|;ZX!Fy zWQmDL#+a<(VlZe>vP4q0$WoTEMV9Q6wXsIFVxqA|uI2lgzTf-!{`&p(e*b~ wCIiL^7ky*uvXmG7ry RG;En zjFRGSHB&?u$%z`c1T1X49a#9us5DnF@+cfH7WF*Bz`Wkm!m$}FcC(of&`W*J(g3z< z(1~j12xNN29>%M*b9mw=!Grs5qjYItRWC}}mbm;4r*(ez=zu4(U`p}o8lT0iO8I~x z{n6z;J22JX+zV4Q(@mb2v_iti47Ji^G|(i6vqyyHoI=u?Y?IHs?K+T$ksE%3>+{r! z g+h_CNElW6|JXF9$ogj`3qi$J4+ST)gv{9k26`+5BIa zj%qhH=e%brDTCD8T;BK@k-lyc#yiSg>v~}~L|Ls|!*Z0Bc29&ks*tNE)dgZ6BR;MW zHLcM0yn<~wvLV+2t6{bx_$cCji}h*d(-ISUJQs>XO7a9S{nz$tR2UMIyHxVFyz3 Mv#B32p!I 9iyQo}Jd1_?ocisJ2`55Gr&e#o4ljuk9t2mh9t z4lhv=tFN&NS)a(Xo7;K<+^`S&$0u(1=s*_KTNT54ZH@+I@aO7BN(xp& t!idpadrT=F(lF^ UGbMQkouY|M zMIf@SHD+Lv&%EQ#H#O1-f}xjaE faHRuUlnu}N;8=ZGPWOSpb zwU!&V5$c?agl8ABqi73j5|=9~@w~Q+O-Z%>N2g{J+{uohu@r>jwBi{-YI`Vuc!DI; z<#p2y@a>nfF%xV0-k 3&x;O(c-5 zYPbJgx@1;G8IFUp*c1VrxFS_t 68U3w+%4@i!B21Q^dzgX34~ur}M(2F~8JaVnMVCh_p~sVl{P%2{ znS*dk#n(NvnZ~cK>rm1bTN4@ZV;b|$0Bk3>51!>w+^B9UsI10H+S-mi`!ENss5x{U z+?IUI3O;@-K)EF+Y9e$$aLTsyLn!krT9ByH_fTdUuUkC-O*?cNP6T{PLML_z6OTom zigmW6Lbfee+xA_L+t0ko=_-lkbHPNNuy_FT_1Yv02!BqR?3LV850|v9MLFyDhSq6I z@nv?}Tn*dfXl&Tc$;hhZ2$|MV(XBb#R;^{0K1nG#sGGxOnOhtw>h?cYn0e&$x!=&q z)%RM2JHG78%Yh2zuilNa)Y)?f3UB3=cIA!e89FM}&0}8dnhf<*`rcQ^cjB(iIs1K< zFRP)91MW@n;llf@-}*1)Um$gKub2N}X}plREN-{cq1Iz}qwcwAL2Axt02o|9cv>H5 zM?gBXK+tJ{3Y{^Mt mmKgGr zLqn!>v%Pl 3(lv4Y0f_tpt9Y45t_GGc3u-q?HkHT&W;*L@ltuM#b@$_zoK9aWLL zKZ0Cf+Ws5!9mK@M&h7^iP2{&r{tkn;1LF8y5e+dMEg9>O0hdjuLQf5Qc^mAlkwMK; zy 1{x^4H3HRdX z7SZC 3;s`J;DH@RTlbO*ff+K!8rM|Gr{1 zGhGe4=q*^c#0VKhA%>MWnvlWIV&THvlllT5FMyUGa*HJ=x)`+1cyE$0eQB*8stADU z0>lxzpnyQ^EBv6%CatdCHpx(CJUTi`&hZD0`582@6Hkyh_3{ZxZOiL{?Vfj~uN>~j zL2mqz8pkj~Sg1)Z7EMsN=zQD=?{$UO^=J>E=gIkfs=%_3{+}g3$G+~ek4j8_e0lD) z5CU3AF?eAfZ@==pEO;-j#&4jz1Zz6XE5P^gPnm+z4}3;<^a;9 8>C7%baB=yROy!SPPF1xp7xawQ!y^{`NsXN87f(wV z@JHx}a&2>niEl<&y2WT&UllR;%pL5>ApSub8Yw?A8X~}3l%aXZNbdZDpTwHu>lPN= zI6prZWr4vr0X{Mvq1Bk*A9R{&ZibZ8>7dQUp5>`prKiDESsw**!2j|yT-hJXxj*|K zJp*NJ%>!U~;Ibd>*n02b3Ggj?v;hg{nD~Eei}qjJyI%%r0||wNQgoYu<%ue3(eMLb zdMLScwxK6sFy94|20~2@5K-s{Npr{7obbe;tuJ$BwKG8R1N}m+$aa7aPiK x237U-r)sBhY=DNQd~Xj+AJ^&L22**{5Bq6=Q2OJ_6~OZacnS^q zY_u|qeU6iU+LEE-3iS2%Jey#2b9bjhPG@hvZ}G1E1SVZr$R1YD-hBp83Kf8f4c(UF zj#Za))r2yB*?jxk7?)P|hrg#;;o9}uf6d<7+FHNN)=(-X=!JO*Mm>vLR5XzVCKZ@? zqi@OkFZu2*QB_GYnOsy-vb8Et6{tp_V`8I$y%+5Dt4P&8eA}KrIg*;13J9LGd?i?Z z4IYhtQd{W#M*Q#em{dyC`W2gh94JX&(0>}-`R_S{4)iW(pbv`rg6;zDpbVFcuAs`1 H&XNBDnAF|e literal 0 HcmV?d00001 diff --git a/docs/Queue/blocked-queue.md b/docs/Queue/blocked-queue.md new file mode 100644 index 000000000..e58583639 --- /dev/null +++ b/docs/Queue/blocked-queue.md @@ -0,0 +1,343 @@ +--- +id: blocked-queue-in-dsa +title: Blocked Queue Data Structure +sidebar_label: Blocked Queue +sidebar_position: 1 +description: "A blocked queue is a linear data structure that operates on the First In First Out (FIFO) principle but includes mechanisms to block and unblock threads when the queue is empty or full. This is particularly useful in concurrent programming." +tags: [dsa, data-structures, BlockedQueue] +--- + +### Introduction to Blocked Queue + +A **blocked queue** is a linear data structure that follows the First In First Out (FIFO) principle, similar to a regular queue. However, it includes mechanisms to block and unblock threads when the queue is empty or full. This is particularly useful in concurrent programming where multiple threads may need to access the queue simultaneously. + +![alt text](Blocked-queue.png) + +### Blocked Queue Operations + +1. **Enqueue**: Add an element to the back of the queue. +2. **Dequeue**: Remove the element from the front of the queue. +3. **Peek**: Retrieve the element at the front of the queue without removing it. +4. **isEmpty**: Check if the queue is empty. +5. **isFull**: Check if the queue is full. +6. **Size**: Get the number of elements in the queue. + +### Pseudocode + +#### Basic Operations + +1. **Enqueue**: + + ```text + function enqueue(blockedQueue, element): + if isFull(blockedQueue): + blockThread() // Block the thread until space is available + blockedQueue.rear = (blockedQueue.rear + 1) % blockedQueue.size + blockedQueue.elements[blockedQueue.rear] = element + unblockThread() // Unblock any waiting threads + ``` + +2. **Dequeue**: + + ```text + function dequeue(blockedQueue): + if isEmpty(blockedQueue): + blockThread() // Block the thread until an element is available + frontElement = blockedQueue.elements[blockedQueue.front] + blockedQueue.front = (blockedQueue.front + 1) % blockedQueue.size + unblockThread() // Unblock any waiting threads + return frontElement + ``` + +3. **Peek**: + + ```text + function peek(blockedQueue): + if isEmpty(blockedQueue): + return "Queue is empty" + return blockedQueue.elements[blockedQueue.front] + ``` + +4. **isEmpty**: + + ```text + function isEmpty(blockedQueue): + return blockedQueue.front == blockedQueue.rear + ``` + +5. **isFull**: + + ```text + function isFull(blockedQueue): + return (blockedQueue.rear + 1) % blockedQueue.size == blockedQueue.front + ``` + +6. **Size**: + + ```text + function size(blockedQueue): + return (blockedQueue.rear - blockedQueue.front + blockedQueue.size) % blockedQueue.size + ``` + +### Implementation in Python, C++, and Java + +#### Python Implementation + +```python +import threading + +class BlockedQueue: + def __init__(self, size): + self.size = size + self.elements = [None] * size + self.front = 0 + self.rear = 0 + self.lock = threading.Lock() + self.not_empty = threading.Condition(self.lock) + self.not_full = threading.Condition(self.lock) + + def enqueue(self, element): + with self.not_full: + while self.is_full(): + self.not_full.wait() + self.rear = (self.rear + 1) % self.size + self.elements[self.rear] = element + self.not_empty.notify() + + def dequeue(self): + with self.not_empty: + while self.is_empty(): + self.not_empty.wait() + frontElement = self.elements[self.front] + self.front = (self.front + 1) % self.size + self.not_full.notify() + return frontElement + + def peek(self): + with self.lock: + if self.is_empty(): + return "Queue is empty" + return self.elements[self.front] + + def is_empty(self): + return self.front == self.rear + + def is_full(self): + return (self.rear + 1) % self.size == self.front + + def size(self): + return (self.rear - self.front + self.size) % self.size + +# Example usage +bq = BlockedQueue(5) +bq.enqueue(10) +bq.enqueue(20) +print(bq.dequeue()) # Output: 10 +print(bq.peek()) # Output: 20 +print(bq.is_empty()) # Output: False +print(bq.size()) # Output: 1 +``` + +#### C++ Implementation + +```cpp +#include +#include +#include +using namespace std; + +class BlockedQueue { +private: + int *elements; + int front, rear, size; + mutex mtx; + condition_variable not_empty, not_full; + +public: + BlockedQueue(int size) { + this->size = size; + elements = new int[size]; + front = rear = 0; + } + + void enqueue(int element) { + unique_lock lock(mtx); + not_full.wait(lock, [this] { return !is_full(); }); + rear = (rear + 1) % size; + elements[rear] = element; + not_empty.notify_one(); + } + + int dequeue() { + unique_lock lock(mtx); + not_empty.wait(lock, [this] { return !is_empty(); }); + int frontElement = elements[front]; + front = (front + 1) % size; + not_full.notify_one(); + return frontElement; + } + + int peek() { + lock_guard lock(mtx); + if (is_empty()) { + cout << "Queue is empty" << endl; + return -1; // Indicating empty + } + return elements[front]; + } + + bool is_empty() { + return front == rear; + } + + bool is_full() { + return (rear + 1) % size == front; + } + + int size_of_queue() { + return (rear - front + size) % size; + } + + ~BlockedQueue() { + delete[] elements; + } +}; + +// Example usage +int main() { + BlockedQueue bq(5); + bq.enqueue(10); + bq.enqueue(20); + cout << bq.dequeue() << endl; // Output: 10 + cout << bq.peek() << endl; // Output: 20 + cout << boolalpha << bq.is_empty() << endl; // Output: false + cout << bq.size_of_queue() << endl; // Output: 1 + return 0; +} +``` + +#### Java Implementation + +```java +import java.util.concurrent.locks.Condition; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; + +public class BlockedQueue { + private int[] elements; + private int front, rear, size; + private final Lock lock = new ReentrantLock(); + private final Condition notEmpty = lock.newCondition(); + private final Condition notFull = lock.newCondition(); + + public BlockedQueue(int size) { + this.size = size; + elements = new int[size]; + front = rear = 0; + } + + public void enqueue(int element) { + lock.lock(); + try { + while (is_full()) { + notFull.await(); + } + rear = (rear + 1) % size; + elements[rear] = element; + notEmpty.signal(); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + } finally { + lock.unlock(); + } + } + + public int dequeue() { + lock.lock(); + try { + while (is_empty()) { + notEmpty.await(); + } + int frontElement = elements[front]; + front = (front + 1) % size; + notFull.signal(); + return frontElement; + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + return -1; // Indicating underflow + } finally { + lock.unlock(); + } + } + + public int peek() { + lock.lock(); + try { + if (is_empty()) { + System.out.println("Queue is empty"); + return -1; // Indicating empty + } + return elements[front]; + } finally { + lock.unlock(); + } + } + + public boolean is_empty() { + return front == rear; + } + + public boolean is_full() { + return (rear + 1) % size == front; + } + + public int size_of_queue() { + return (rear - front + size) % size; + } + + public static void main(String[] args) { + BlockedQueue bq = new BlockedQueue(5); + bq.enqueue(10); + bq.enqueue(20); + System.out.println(bq.dequeue()); // Output: 10 + System.out.println(bq.peek()); // Output: 20 + System.out.println(bq.is_empty()); // Output: false + System.out.println(bq.size_of_queue()); // Output: 1 + } +} +``` + +### Complexity +-**Time Complexity**: + + - Enqueue: $O(1)$ + - Dequeue: $O(1)$ + - Peek: $O(1)$ + - isEmpty: $O(1)$ + - isFull: $O(1)$ + - Size: $O(1)$ +-**Space Complexity**: $O(n)$, where $n$ is the number of elements that can be stored in the blocked queue. + +### Example + +Consider a blocked queue with the following operations: + +1. Enqueue 10 +2. Enqueue 20 +3. Dequeue +4. Peek +5. Check if empty +6. Get size + +**Operations**: + +- Enqueue 10: Queue becomes [10, _, _, _, _] +- Enqueue 20: Queue becomes [10, 20, _, _, _] +- Dequeue: Removes 10, Queue becomes [_, 20, _, _, _] +- Peek: Returns 20, Queue remains [_, 20, _, _, _] +- isEmpty: Returns false +- Size: Returns 1 + +### Conclusion + +A blocked queue is an efficient data structure that improves the utilization of space and provides thread safety in concurrent programming scenarios. It is widely used in applications such as producer-consumer problems, task scheduling, and resource management. Understanding and implementing a blocked queue can significantly enhance performance and synchronization in multi-threaded environments. \ No newline at end of file From 928118637e4ffebc3152d5e704fdb5617d374ff5 Mon Sep 17 00:00:00 2001 From: Subashree-selvaraj Date: Sun, 27 Oct 2024 20:31:25 +0530 Subject: [PATCH 4/5] Add detailed document on K-D Tree Algorithm --- docs/Trees/k-d tree algorithm.md | 193 +++++++++++++++++++++++++++++++ 1 file changed, 193 insertions(+) create mode 100644 docs/Trees/k-d tree algorithm.md diff --git a/docs/Trees/k-d tree algorithm.md b/docs/Trees/k-d tree algorithm.md new file mode 100644 index 000000000..0d0168bed --- /dev/null +++ b/docs/Trees/k-d tree algorithm.md @@ -0,0 +1,193 @@ +--- +id: kd-tree +title: K-D Tree +sidebar_label: K-D Tree +sidebar_position: 3 +description: "A K-D Tree is a space-partitioning data structure for organizing points in a k-dimensional space." +tags: [Data Structures, K-D Tree, Algorithms] +--- + +# K-D Tree + +## Overview +A **K-D Tree** (short for k-dimensional tree) is a space-partitioning data structure used for organizing points in a k-dimensional space. K-D Trees are useful for various applications such as range searches and nearest neighbor searches. They are a generalization of binary search trees to multiple dimensions. + +## Features +- **Space Partitioning**: Divides the space into nested half-spaces. +- **Efficient Searches**: Supports efficient range and nearest neighbor searches. +- **Balanced Structure**: Can be balanced to ensure efficient operations. + +## Table of Contents +- [How It Works](#how-it-works) +- [Operations](#operations) + - [Insertion](#insertion) + - [Deletion](#deletion) + - [Search](#search) + - [Nearest Neighbor Search](#nearest-neighbor-search) +- [Code Example](#code-example) +- [Applications](#applications) +- [Time Complexity](#time-complexity) + +## How It Works +In a K-D Tree: +- Each node represents a k-dimensional point. +- The tree alternates between the k dimensions at each level of the tree. +- The root node splits the space into two half-spaces based on the first dimension, the children of the root split based on the second dimension, and so on. + +### Construction +1. **Choose Axis**: Select the axis based on the depth of the node modulo k. +2. **Sort Points**: Sort the points based on the chosen axis. +3. **Median Point**: Choose the median point to ensure balanced partitions. +4. **Recursively Construct**: Recursively construct the left and right subtrees using the points before and after the median. + +## Operations + +### Insertion +To insert a new point: +1. Start at the root and choose the axis based on the depth. +2. Compare the point with the current node's point based on the chosen axis. +3. Recursively insert the point into the left or right subtree based on the comparison. + +### Deletion +To delete a point: +1. Find the node containing the point. +2. Replace the node with a suitable candidate from its subtrees to maintain the K-D Tree properties. +3. Recursively adjust the tree to ensure balance. + +### Search +To search for a point: +1. Start at the root and choose the axis based on the depth. +2. Compare the point with the current node's point based on the chosen axis. +3. Recursively search the left or right subtree based on the comparison. + +### Nearest Neighbor Search +To find the nearest neighbor: +1. Start at the root and traverse the tree to find the leaf node closest to the target point. +2. Backtrack and check if there are closer points in the other half-spaces. +3. Use a priority queue to keep track of the closest points found. + +## Code Example + +### Python Example (K-D Tree): + +```python +class Node: + def __init__(self, point, axis, left=None, right=None): + self.point = point + self.axis = axis + self.left = left + self.right = right + +class KDTree: + def __init__(self, points): + self.k = len(points[0]) if points else 0 + self.root = self.build_tree(points, depth=0) + + def build_tree(self, points, depth): + if not points: + return None + + axis = depth % self.k + points.sort(key=lambda x: x[axis]) + median = len(points) // 2 + + return Node( + point=points[median], + axis=axis, + left=self.build_tree(points[:median], depth + 1), + right=self.build_tree(points[median + 1:], depth + 1) + ) + + def insert(self, root, point, depth=0): + if root is None: + return Node(point, depth % self.k) + + axis = root.axis + if point[axis] < root.point[axis]: + root.left = self.insert(root.left, point, depth + 1) + else: + root.right = self.insert(root.right, point, depth + 1) + + return root + + def search(self, root, point, depth=0): + if root is None or root.point == point: + return root + + axis = root.axis + if point[axis] < root.point[axis]: + return self.search(root.left, point, depth + 1) + else: + return self.search(root.right, point, depth + 1) + + def nearest_neighbor(self, root, point, depth=0, best=None): + if root is None: + return best + + axis = root.axis + next_best = None + next_branch = None + + if best is None or self.distance(point, root.point) < self.distance(point, best.point): + next_best = root + else: + next_best = best + + if point[axis] < root.point[axis]: + next_branch = root.left + other_branch = root.right + else: + next_branch = root.right + other_branch = root.left + + next_best = self.nearest_neighbor(next_branch, point, depth + 1, next_best) + + if self.distance(point, next_best.point) > abs(point[axis] - root.point[axis]): + next_best = self.nearest_neighbor(other_branch, point, depth + 1, next_best) + + return next_best + + def distance(self, point1, point2): + return sum((x - y) ** 2 for x, y in zip(point1, point2)) ** 0.5 + +# Example usage: +points = [(2, 3), (5, 4), (9, 6), (4, 7), (8, 1), (7, 2)] +kd_tree = KDTree(points) + +# Insert a new point +kd_tree.insert(kd_tree.root, (3, 6)) + +# Search for a point +result = kd_tree.search(kd_tree.root, (5, 4)) +print("Found:", result.point if result else "Not found") + +# Find the nearest neighbor +nearest = kd_tree.nearest_neighbor(kd_tree.root, (9, 2)) +print("Nearest neighbor:", nearest.point if nearest else "None") +``` + +### Output: +``` +Found: (5, 4) +Nearest neighbor: (8, 1) +``` + +## Applications +- **Databases**: Used for maintaining sorted data in databases where frequent insertions and deletions are required. +- **Memory Management**: Efficiently manage free memory blocks in systems. +- **Auto-completion**: Used in applications that require predictive text suggestions. + +## Time Complexity + +| Operation | Average Time | Worst Case Time | +|----------------------|--------------|-----------------| +| **Search** | O(log n) | O(n) | +| **Insertion** | O(log n) | O(n) | +| **Deletion** | O(log n) | O(n) | +| **Nearest Neighbor** | O(log n) | O(n) | + +> **Note**: The worst-case time complexity arises in unbalanced cases; balanced K-D Trees maintain an average of O(log n) for most operations. + +## Conclusion +K-D Trees are powerful data structures for organizing and searching points in multi-dimensional spaces. They are essential for applications that require efficient spatial searches and nearest neighbor queries. +--- \ No newline at end of file From 678bb596685edea212c870043e077c24e8309639 Mon Sep 17 00:00:00 2001 From: Ajay Dhangar <99037494+ajay-dhangar@users.noreply.github.com> Date: Tue, 29 Oct 2024 21:48:53 +0530 Subject: [PATCH 5/5] Update README.md --- README.md | 450 +++++++++++++++++++++++++++--------------------------- 1 file changed, 225 insertions(+), 225 deletions(-) diff --git a/README.md b/README.md index e9b80a501..a18972078 100644 --- a/README.md +++ b/README.md @@ -222,10 +222,10 @@ Thanks to these amazing people who have contributed to the **Algo** project: