//counLlng number of words spaces ln a sLrlng

lmporL [avalo*
publlc class SLrlngfun

sLaLlc SLrlng sLr//Lo sLore Lhe sLrlng
publlc sLaLlc vold maln(SLrlng args)Lhrows lCLxcepLlon

8uffered8eader brnew 8uffered8eader(new lnpuLSLream8eader(SysLemln))
SysLemouLprlnLln(LnLer Lhe sLrlng )
sLrbrreadLlne()
spaces_words()

publlc sLaLlc vold spaces_words()

lnL word0//Lo sLore number of words
lnL space0//Lo sLore number of spaces
SLrlng LsLrLrlm()
//Lo remove whlLe spaces from boLh ends
for(lnL l0lLlengLh()l++)
//Lo flnd number of words

char cLcharAL(l)
lf(c )
word++

for (lnL [0[sLrlengLh()[++)
//Lo flnd number of spaces

char chsLrcharAL([)
lf(ch )
space++

SysLemouLprlnLln(number of words +(word+1))
SysLemouLprlnLln(number of spaces +space)

//Lnd of program





//program lmplemenLlng sorLlng and searchlng
lmporL [avalo*
class sorL //deflnlng class

lnL arr
publlc vold lnpuL_daLa()Lhrows lCLxcepLlon

8uffered8eader brnew 8uffered8eader(new lnpuLSLream8eader(SysLemln))
SysLemouLprlnLln(LnLer Lhe array of 13 elemenLs)
arrnew lnL30
lnL b0
for(lnL l0l13l++)

blnLegerparselnL(brreadLlne())
arrlb

SysLemouLprlnLln(Array before SorLlng)
for(lnL [0[13[++)
SysLemouLprlnL(arr[+ )
SysLemouLprlnLln()

publlc vold bubble()Lhrows lCLxcepLlon //sorLlng

lnL Lmp0
for(lnL l0l13l++)

for(lnL [0[14l[++)

lf(arr[arr[+1)

Lmparr[
arr[arr[+1
arr[+1Lmp



SysLemouLprlnLln(Array afLer sorLlng)
for(lnL k0k13k++)
SysLemouLprlnL(arrk+ )
SysLemouLprlnLln()

publlc vold blnary_search()Lhrows lCLxcepLlon //searchlng


8uffered8eader brnew 8uffered8eader(new lnpuLSLream8eader(SysLemln))
SysLemouLprlnLln(LnLer Lhe number Lo be searched)
lnL blnLegerparselnL(brreadLlne())
lnL u14l0flag0mld0pos0
whlle(lu)

mld(l+u)/2
lf(arrmldb)
lmld+1
else lf(arrmldb)
umld1
lf(arrmldb)

posmld+1
flag1
break


lf(flag1)
SysLemouLprlnLln(b+ ls presenL ln +pos+poslLlon)
else
SysLemouLprlnLln(b+ ls noL presenL)


publlc class search

publlc sLaLlc vold maln(SLrlng args)Lhrows lCLxcepLlon

sorL snew sorL()
slnpuL_daLa()
sbubble()
sblnary_search()







//program Lo merge Lwo arrays lnLo a Lhlrd array
lmporL [avalo*
publlc class merge

publlc sLaLlc vold maln(SLrlng args)Lhrows lCLxcepLlon

8uffered8eader brnew 8uffered8eader(new lnpuLSLream8eader(SysLemln))
SysLemouLprlnLln(LnLer Lhe number of elemenLs ln flrsL array )
lnL nlnLegerparselnL(brreadLlne())
lnL Anew lnLn
SysLemouLprlnLln(LnLer elemenLs of flrsL array )
for(lnL l0lnl++)

lnL xlnLegerparselnL(brreadLlne())
Alx

SysLemouLprlnLln(LnLer Lhe number of elemenLs ln second array )
lnL mlnLegerparselnL(brreadLlne())
lnL 8new lnLm
SysLemouLprlnLln(LnLer elemenLs of second array )
for(lnL l0lml++)

lnL ylnLegerparselnL(brreadLlne())
8ly

lnL Cnew lnLm+n
for(lnL l0lnl++)//sLorlng elemenLs of flrsL ln Lhlrd
ClAl
for(lnL [nk0[n+m[++k++)
//sLorlng elemenLs of seceond ln Lhlrd
C[8k
SysLemouLprlnLln(1he new merged array ls )
for(lnL k0kn+mk++)
SysLemouLprlnL(Ck+ )

//end of program





//program lmplemenLlng LrlgonomeLrlc funcLlons
lmporL [avalo*
class Lrlg

publlc sLaLlc vold check()Lhrows lCLxcepLlon

8uffered8eader brnew 8uffered8eader(new lnpuLSLream8eader(SysLemln))
SysLemouLprlnLln(LnLer Lhe value of x)
lnL xlnLegerparselnL(brreadLlne())
SysLemouLprlnLln(sln x+MaLhsln(x))
SysLemouLprlnLln(cos x+MaLhcos(x))
SysLemouLprlnLln(Lan x+MaLhLan(x))









//a program Lo flnd Lhe nearesL Lwlnprlmes from a glven number
lmporL [avalo*
class Lwlnprlme

lnL n0
publlc sLaLlc vold maln(SLrlng args)Lhrows lCLxcepLlon

8uffered8eader brnew 8uffered8eader(new lnpuLSLream8eader(SysLemln))
SysLemouLprlnLln(LnLer a number)
Lwlnprlme Lwnew Lwlnprlme()
LwnlnLegerparselnL(brreadLlne())
LwsearchLw()

publlc vold searchLw()

lnL l[f0
lf(lsprlme(n1)1lsprlme(n+1)1)
SysLemouLprlnLln(1he nearesL 1wlnprlme numbers are +(n1)+ and +(n+1))
else

for(ln[n[++l)

lf(lsprlme(l)1lsprlme(l2)1)

SysLemouLprlnLln(1he nearesL Lwln prlmes are +(l2)+ and +l)
f1

lf(lsprlme([)1lsprlme([+2)1)

SysLemouLprlnLln(1he nearesL Lwln prlmes are +([)+ and +([+2))
f1

lf(f1)
break



publlc lnL lsprlme(lnL v)
// funcLlon Lo check wheLher a number ls prlme or noL

lnL k0
for(lnL l1l+vl++)
lf(vl0)

k++

lf(k2)
reLurn 1
else
reLurn 0












//a class Lo prlnL all lucky numbers beLween a glven range
lmporL [avalo*
class lucky

publlc sLaLlc vold maln(SLrlng args)Lhrows lCLxcepLlon


lnL n0l0v0c0
8uffered8eader brnew 8uffered8eader(new lnpuLSLream8eader(SysLemln))
SysLemouLprlnLln(LnLer Lhe number )
nlnLegerparselnL(brreadLlne())
lnL anew lnLn
for(l0lnl++)
all+1
for(v1vnv++)//v sLores Lhe dlff ln poslLlons aL whlch Lhe numbers are deleLed

for(l0lnl++)
lf(al!0)

lf(cv)//checklng lf Lhe numbers covered ls equal ln poslLlon

al0
c0

else
c++//a counLer Lo numbers covered

c0

for(l0lnl++)
lf(al!0)
SysLemouLprlnLln(al)








//a class Lo lmplemenL Lhe concepL of Cueue
lmporL [avalo*
class Cueue

lnL queuenew lnL10fronL1rear1
publlc sLaLlc vold maln(SLrlng args)Lhrows lCLxcepLlon

lnL lnum0
8uffered8eader brnew 8uffered8eader(new lnpuLSLream8eader(SysLemln))
Cueue Cenew Cueue()
SysLemouLprlnLln(LnLer Lhe numbers Lo be lnserLed ln Cueue)
for(l0l10l++)

numlnLegerparselnL(brreadLlne())
CelnserL(num)

SysLemouLprlnLln(1he numbers lnserLed(ln order) are )
for(l0l10l++)
SysLemouLprlnLln(Cequeuel)
SysLemouLprlnLln(1he numbers(ln order of deleLlon) are )
for(l0l10l++)
SysLemouLprlnLln(Cedel())

publlc vold lnserL(lnL n)

lf(rear1)

fronLrear0
queuerearn

else lf(rear+1queuelengLh)
queue++rearn

publlc lnL del()

lnL m
lf(lsLmpLy())
reLurn 0
else

mqueuefronL
lf(fronLrear)
fronLrear1
else
fronL++
reLurn m


publlc boolean lsLmpLy()

reLurn fronL1








//llnkedllsL
lmporL [avalo*
class node

proLecLed lnL daLa
proLecLed node llnk
publlc node()

llnknulldaLa0

publlc node(lnL dnode n)

daLadllnkn

publlc vold seLllnk(node n)

llnkn

publlc vold seLuaLa(lnL d)

daLad

publlc node geLllnk()

reLurn llnk

publlc lnL geLuaLa()

reLurn daLa


class llnkedLlsL

proLecLed node sLarL
publlc llnkedLlsL()

sLarLnull

publlc boolean lsLmpLy()

reLurn sLarLnull

publlc vold lnserL(lnL val)

node npLrpLrsavenull
npLrnew node(valnull)
boolean lnsfalse
lf(sLarLnull)
sLarLnpLr
else lf(valsLarLgeLuaLa())

npLrseLllnk(sLarL)
sLarLnpLr

else
savesLarL
pLrsLarLgeLllnk()
whlle(pLr!null)

lf(valsavegeLuaLa() valpLrgeLuaLa())

saveseLllnk(npLr)
npLrseLllnk(pLr)
lnsLrue
break

else

savepLr
pLrpLrgeLllnk()

lf(lnsfalse)

saveseLllnk(npLr)



publlc vold dlsplay()

node pLrsLarL
SysLemouLprlnL(sLarLgeLuaLa()+)
pLrsLarLgeLllnk()
whlle(pLrgeLllnk()!null)

SysLemouLprlnL(pLrgeLuaLa()+)
pLrpLrgeLllnk()

SysLemouLprlnL(pLrgeLuaLa()+!!!!)
SysLemouLprlnLln()


publlc class llnkLlsL1esL

proLecLed sLaLlc llnkedLlsL S1
publlc sLaLlc vold maln(SLrlng args)

lnL num
S1new llnkedLlsL()
8uffered8eader brnew 8uffered8eader(new lnpuLSLream8eader(SysLemln))
SysLemouLprlnLln(SLarLlng LlsL 1esL for lnserLlon)
for(lnL a0a3++a)

SysLemouLprlnLln(LnLer a number )
Lry
numlnLegerparselnL(brreadLlne())
S1lnserL(num)
SysLemouLprlnLln(lnserLed +num)

caLch(LxcepLlon e)

SysLemouLprlnLln(e)


SysLemouLprlnLln(CreaLed LlsL ls )
S1dlsplay()
SysLemouLprlnLln(LlsL 1esL Cver)