DEV Community: Arsen Mazmanyan

Գտնել զանգվածների ընդհանուր էլեմենտները

Arsen Mazmanyan — Mon, 20 Dec 2021 09:31:30 +0000

Բարև սիրելի ծրագրավորող (կամ ապագա ծրագրավորող)։

Այսօր կնայենք հարցազրույցների ժամանակ ամենատարածված խնդիրներից մեկը՝ մի մի քանի զանգվածի ընդհանուր էլեմենտները գտնելու խնդիրը և այդ խնդրի լուծման եղանակներից մի քանիսը։

Սակայն մինչև առաջ անցնելը 2 կարևոր բան
֊ Խնդիրների լուծումները կլինեն JavaScript լեզվով,
֊ Ես ներկայացնում եմ խնդիրը լուծելու գաղափարները և չեմ բացատրելու, թե որ ֆունկցիան իրենից ինչ է ներկայացնում, սակայն կտեղադրեմ համապատասխան հղումները, որպեսզի դու ինքդ ուսումնասիրես դրանք:

Եթե սիրում ես խնդիրներ լուծել, ուրեմն արդեն լուծել ես այսպիսի խնդիր։ Կամ հարցազրույցի ժամանակ առընչվել ես այսպիսի խնդրի։

Նախ հասկանանք խնդիրը։
Ո՞ր էլեմենտներն են, որ կարող ենք համարել ընդհանուր։
Եթե կա այնպիսի էլեմենտ, որը պարունակվում է մեզ տրված զանգվածներից յուրաքանչյուրում, ապա այն համարվումէ ընդհանուր էլեմենտ։

Այսինքն, եթե ստացել ենք 3 զանգված՝
["a", "b", "a", "b", "d", "c"],
["a", "c", "d", "e", "e"],
["a", "x", "y", "c"],

Այս դեպքում մեր պատասխանը կլինի 'a','c': Որովհետև դրանք այն էլեմենտներն են, որոնք պարունակվում են մեր զանգվածներից բոլորի մեջ։

Ինչպես գրեթե ցանկացած խնդիր, այս խնդիրը նույնպես ունի իր տարատեսակները։ Այդ պատճառով հստակցնենք որոշակի պայմաններ։

Մեզ կփոխանցվի երկչափ զանգված, որի մեջի զանգվածներից պետք է գտնենք ընդհանուր էլեմենտները։ Մեր զանգավծները պարունակելու են միայն տառեր։ Զանգվածների երկարությունը չի գերազանցում 100֊ը։ Զանգվածների քանակը 1֊ից ավել է։ Զանգվածների մեջ էմենետները կարող են կրկնվել (['a', 'b', 'a', 'b', 'c']), սակայն այդ դեպքում հաշվում ենք դրանցից միայն մեկը։ Որպես պատասխան վերադարձնում ենք զանգված, որի մեջ ներառված են ընդհանուր էլեմենտները։

Լուծման գաղափարներից մեկը այն է, որ վերցնենք զանգվածերից մեկի էլեմենտները և ստուգենք, թե դրանցից որոնք են պարունակվում մնացած զանգվածներում։ Եթե գտնենք այնպիսի զանգված, որը չի պարունակում տվյալ էլեմենտը, կանցնենք առաջ և կստուգենք հաջորդ էլեմենտը։ Իսկ եթե հասնենք վերջին զանգվածին և այն նույնպես պարունակի տվյալ էլեմենտը, նշանակում է այն պարունակվում է բոլոր զանգվածներում։ Հակառակ դեպքում նախորդ պայմանով արդեն դուրս եկած կլինեինք ցիկլի մեջից և վերջին զանգվածին չէինք հասնի։

Սակայն, ինչպես նշեցի, զանգվածների մեջ էլեմենտները կարող են կրկնվել, իսկ զանգվածի միջից դուպլիկատները հեռացնելու համար կօգտվեմ Set-ից (Զանգվածի միջից դուպլիկատները հեռացնելու խնդրին և դրա լուծումներին կարող ես ծանոթանալ այստեղ)։

Ստորև ներկայացրել եմ 2 լուծում, որոնք միմյանցից տարբերվում են միայն զանգվածի մեջ էլեմենտը գտնելու մեթոդով։ Մի դեպքում օգտագործվում է Array.indexOf() մեթոդը, մյուս դեպքում Array.includes()֊ը։

Կոդը տեղադրված է այս հղման մեջ

Այս խնդիրը կարող ենք լուծել նաև ուրիշ ձևով։ Նախ պետք է զանգվածների միջից հեռացնենք դուպլիկատները, որից հետո մնում է հաշվենք, թե յուրաքանչյուր էլեմենտ քանի անգամ է հանդիպում մեզ տրված զանգվածների մեջ։ Եթե կա էլեմենտ, որին հանդիպում ենք այնքան, ինչքան մեր զանգվածների քանակն է, ուրեմն այդ էլեմենտը հանդիպում է բոլոր զանգվածներում։ Վստահ կարող ենք այսպիսի պնդում կատարել, քանի որ նախորդ քայլով արդեն հեռացրել էինք յուրաքանչյուր զանգվածում գտնվող դուպլիկատները։

Էլեմենտների հանդիպելու քանակը հաշվելու համար կօգտագործենք օբյեկտ, որի մեջ որպես key կպահենք այն տառը, որի քանակը հաշվելու ենք, իսկ որպես այդ key֊ի property կպահենք նրան հանդիպելու քանակը։

Կոդը տեղադրված է այս հղման մեջ

Հույս ունեմ, այս նյութը քեզ օգնեց նոր գաղափարներ և նոր գիտելիք ստանալու հարցում։ Իսկ եթե ունես այնպիսի լուծման եղանակ, որը այստեղ նշված չէ, շատ ուրախ կլինեմ, եթե քո տարբերակը ուղարկես ինձ, այդպիսով փորձի փոխանակում կանենք։

Արդյո՞ք թիվը պարզ է (Prime Numbers)

Arsen Mazmanyan — Fri, 03 Dec 2021 10:26:34 +0000

Բարև սիրելի ծրագրավորող (կամ ապագա ծրագրավորող)։

Այսօր կնայենք հարցազրույցների ժամանակ ամենատարածված խնդիրներից մեկը՝ թվի պարզությունը ստւգելու խնդիրը և այդ խնդրի լուծման եղանակներից մի քանիսը։

Նախ հասկանանք խնդիրը։
Ո՞ր թվերն են համարվում պարզ թվեր։
Պարզ թիվ է կոչվում այն բնական թիվը (բացի 1-ից), որը ունի միայն երկու բաժանարար։ Այսինքն բաժանվում են միայն մեկի և իր վրա ։

Ի՞նչպես կարող ենք ստուգել թվի պարզ լինելը։
Ենթադրենք մեզ տրված թիվը N թիվն է։
Պարզապես կարող ենք մինչև N բոլոր թվերը հերթով ստուգել և եթե գտնենք 1֊ից և N֊ից տարբեր այնպիսի թիվ, որի վրա N֊ը բաժանելիս ստանում ենք 0 մնացորդ, ուրեմն թիվը պարզ չէ։

Ընդունենք, որ մեր ֆունկցիային փոխանցվող արգումենտը միշտ 1֊ից տարբեր բնական թիվ է լինելու {2,3,4,5,...}:

Մեզ պետք է գտնենլ 1֊ից և N֊ից տարբեր թիվ, հետևաբար կարող ենք ստուգել [2, N-1] միջակայքի թվերը, ներառյալ։

Կոդը տեղադրված է այս հղման մեջ

Այս եղանակի վրա կարող ենք որոշակի օպտիմիզացիաներ կատարել։
Օրինակ կարող ենք ստուգել մինչև N/2, որովհետև (N/2, n] միջակայքում այնպիսի թիվ չկա, որի վրա բաժանելիս կստանանք` ամբողջ թիվ (կստանանք 1ից մեծ և 2ից փոքր թվեր)։ Այսպիով մեր քալերի քանակը 2 անգամ կկրճատվի։

Կոդը տեղադրված է այս հղման մեջ

Սակայն կա մեկ այլ, ավելի օպտիմալ տարբերակ, որը սկզբից կբացատրեմ մաթեմատիկական եղանակով։

Ցանկացած բնական, ոչ պարզ N թիվ կարող ենք ներկայացնել A * B տեսքով, որտեղ A, B֊ն նույնպես բնական թվեր են։
Ունենք M դրական իրական թիվը, որը N թվի քառակուսի դրական արմատն է՝ M = |√ N|:

Քանի որ M * M = N և N = A * B, ապա M * M = A * B

Նկատենք, որ ստորև նշված 3 պայմաններից մեկը միշտ տեղի ունի։

A > M => B < M
A = M => B = M
A < M => B > M

Բոլոր 3 դեպքերի համար 1 ընդհանուր բան կա՝ (A,B)-ից փոքրագույնի արժեքը փոքր կամ հավասար է M֊ից (min(A,B) ≤ M):
Հետևաբար նրանցից մեծագույնը մեծ կամ հավասար է M֊ից (max(A,B) ≤ M):

Այսինքն, եթե N թիվը պարզ չէ, ուրեմն [2,M] միջակայքում գոյություն ունի գոնե 1 այնպիսի թիվ, որի վրա N֊ը առանց մնացորդ բաժանվում է։ Հակառակ դեպքում թիվը պարզ է։

Այս ալգորիթմը էլ ավելի քիչ քայլում է կատարվում, քայլերի քանակը հասցնելով √N֊ի։

Կոդը տեղադրված է այս հղման մեջ

Այլ մարդկանց կողմից առաջարկված լուծումներ (մաս 1)

Arsen Mazmanyan — Mon, 29 Nov 2021 15:58:57 +0000

Բարև սիրելի ծրագրավորող

Նախորդ 2 փոստերում մենք քննարկեցինք տառերի զանգվածի միջից դուպլիկատները հեռացնելու և բառի պոլինդրոմությունը ստուգելու խնդիրները և դրանց լուծման մի քանի տարբերակ։

Ի ուրախություն ինձ, ինչու չէ նաև քեզ, որոշ մարդիկ այս նյութերը կարդալուց հետո իմ հետ կիսվեցին այս խնդիրները լուծելու իրենց նոր, հետաքրքիր տարբերակներով, որոնցով ես պատրաստվում եմ կիսվել քո հետ։

Սկզբից նայենք տառերի զանգվածի միջից դուպլիկատները հեռացնելու խնդրի նոր լուծումները։ Խնդրի հետ ավելի մանրամասն ծանոթանալու համար կարող ես անցնել այս հղմամբ։

Այս տարբերակը LinkedIn-ով ինձ առաջարկել է Սահակը:

Կոդը կարող ես փորձարկել այստեղ:

Լուծման այս տարբերակը հիմնված է JavaScrip-ի օբյեկտի՝ եզակի key֊եր պահելու վրա։ Զանգվածի էլեմենտներով obj օբյեկտի key֊եր ենք սարքում։ Այնուհետև վերադարձնում ենք obj֊ի key֊երը զանգվածի տեսքով և խնդիրը լուծված է։

Իհարկե գաղափարին հետևող այլ լուծումներ էլ կարող եք ստանալ։ Ես և Սահակը արել ենք այդ։ Կցանկանամ, որ նաև դուք մտածեք այդ ուղղությամբ և ինքներդ այլ լուծումներ գտնեք։

Նա նաև առաջարկեց Go լեզվով մեկ այլ լուծում, որը ունի այսպիսի տեսք։

Մյուս տարբերակը ինձ առաջարկել է JavaScript Armenia Տելեգրամ չատի օգտատեր Կարոն։

Կոդը կարող ես փորձարկել այստեղ:

Լուծման այս եղանակը հիմնված է ES6 ստանդարտով մեզ ներկայացած ֆունկցիաների վրա։ Այս դեպքում զանգվածը ֆիլտրում ենք և պահում ենք միայն այն էլեմենտները, որոնց ինդեքսը հավասար է այդ զանգվածում իրեն հավար էլեմենտի վերջին ինդեքսին։ Այսինք էլեմենտը մնում է միայն այն դեպքում, երբ այն միակն է զանգվածում։

Անցնենք առաջ և դիտարկենք պոլինդրոմ բառերի խնդրի համար առաջարկված նոր լուծումները։ Այս խնդրի հետ ավելի մանրամասն ծանոթանալու համար կարող ես անցնել այս հղմամբ։

Այս խնդրի լուծումներից մեկը ինձ LinkedIn֊ով առաջարկել է Գուրգենը:

Կոդը կարող ես փորձարկել այստեղ:

Խնդրի լուծման այս տարբերակում պահում ենք 2 ինդեքս, որոնցից մեկը աջ կողմից ստուգվող էլեմենտի ինդեքսն է, մյուսը ձախ կողմից ստուգվողի ինդեքսը։ Ամեն անգամ, տառերի համեմատությունից հետո, եթե նրանք հավասար են, ինդեքսները 1ով ավելացնում ենք, քանի դեռ ձախ ինդեքսը փոքր է աջի ինդեքսից։ Իսկ եթե տառերը նույնը չեն, վերադարձնում ենք false։

Մեկ այլ լուծում առաջարկել է Հայկական ՏՏ համայնք Տելեգրամ չատի օգտատեր Հասմիկը։

Կոդը կարող ես փորձարկել այստեղ:

Այս Եղանակով մենք նախ բառը դարձնում ենք փոքրատառ, հետո պահում ենք այն նաև շրջած տեսքով։ Եթե բառը հավասար է իր շրջած արժեքին, ուրեմն այն պոլինդրոմ է։ Հակառակ դեպքում ոչ։

Եվս մեկ անգամ կցանկանամ շնորհակալություն հայտնել նրանց՝ իրենց լուծման տարբերակներով կիսվելու համար։

Հույս ունեմ, այս նյութը քեզ օգնեց նոր գաղափարներ և նոր գիտելիք ստանալու հարցում։
Իսկ եթե ունես մեկ այլ լուծման եղանակ, շատ ուրախ կլինեմ, եթե քո տարբերակը ուղարկես ինձ, այդպիսով փորձի փոխանակում կանենք։

Պոլինդրոմ (palindrome) բառեր

Arsen Mazmanyan — Sun, 21 Nov 2021 09:10:11 +0000

Բարև սիրելի ծրագրավորող (կամ ապագա ծրագրավորող)։

Այսօր կնայենք հարցազրույցների ժամանակ ամենատարածված խնդիրներից մեկը՝ պոլինդրոմ բառերի խնդիրը։

Նախ հասկանանք խնդիրը։
Ի՞նչ է իրենից ներկայացնում պոլինդրոմ բառը։ Պոլինդրոմ կոչվում են այն բառեր/թվերը, որոնք թե՛ աջից, թե՛ ձախից նույն կերպ են կարդացվում։ Այդպիսի բառերի օրինակներից են «շիշ», «Աննա» և նմանատիպ կառուցվածք ունեցող բառերը։ Իսկ թվերից «12321», «12344321» և նմանատիպ մնացած թվերը։

Սակայն ինչպե՞ս վարվել երբ բառի/թվի երկարությունը կենտ թիվ է։ Այսինքն մեջտեղում ունենալու ենք մի տառ, որը ոչ մեկի հետ չենք կարող ստուգել։ Պարզվում է, այս դեպքում մեջտեղի տառը ստուգելու կարիք չկա, որովհետև այն չի ազդում բառի պոլինդրոմության վրա։

Հիմա փորձենք հասկանանք, թե ինչպես կարող ենք լուծել այս խնդիրը։ Պարզվում է, դա այդքան էլ բարդ չէ։ Ուղղակի պետք է առաջին տառը/նիշը համեմատենք վերջից առաջին տառի/նիշի հետ։ Եթե տառերը/նիշերը նույնն են, անցնում ենք առաջ և երկրորդը համեմատում ենք վերջից երկրորդի հետ։ Այդ ամենը անում ենք այնքան, մինչև գտնենք այնպիսի տառերի/նիշերի զույգ, որոնք նույնը չեն։ Այդ դեպքում տրված բառը/թիվը կդադարի պոլինդրոմ լինելուց։ Հակառակ դեպքում, եթե չգտնենք այդպիսի զույգ, ուրեմն թիվը պոլինդրոմ է։

Ծրագրավորման տեսանկյունից ինչպե՞ս կարող ենք հասկանալ բառի/թվի պոլինդրոմությունը։

Գաղափարներից մեկը, որ գալիս է, այն է, որ վերցնենք երկու զանգված, մեկի մեջ տեղավորենք առաջին կեսի տառերը, մյուսի մեջ երկրորդ կեսի տառերը։ Հետո համեմատենք զանգվածների համապատասխան տառերը։

Եթե բառի երկարությունը կենտ թիվ է, ապա պետք է անել այնպես, որ այդ տառը ոչ մի զանգվածի մեջ չգտնվի, քանի որ այն գտնվում է հենց մեջտեղում և չի ազդում բառի պոլինդրոմության վրա։

Դե ինչ, անցնենք առաջ և դիտարկենք այս խնդիրը կոդի տեսանկյունից։

Ընդունենք, որ այս խնդրի դեպքում մեր ֆունկցիային միշտ string տիպի արժեք է փոխանցվելու, որը կարող է ունենալ թե՛ մեծատառ, թե՛ փոքրատառ տառեր։ Սակայն տառի մեծատառ և փոքրատառ լինելը չի ազդում պոլինդրոմության վրա։ Ընդունենք նաև այն, որ փոխանցվող արժեքը կարող է դարակ լինել (դատարկ stirng֊ը (""֊ը) կարող ենք պոլինդրոմ համարել)։

Կոդը տեղադրված է այս հղման մեջ

Այս լուծման օրինակում մենք հայտարարում ենք 2 զագնված։ firstHalf֊ի մեջ տեղավորում ենք բառի առաջին կեսի տառերը, իսկ secondHalf֊ի մեջ երկրորդ կեսի տառերը։

Երկրորդ զանգավծը շրջենք reverse() մեթոդի օգնությամբ։ Հետո ստուգենք firstHalf֊ի առաջին տառը secondHalf֊ի առաջին տառի հետ։ Հետո firstHalf֊ի երկրորդ տառը secondHalf֊ի երկրորդ տառի հետ և այդպես շարունակ։ Եթե գտնենք այնպիսի տառերի զույգ, որոնք նույնը չեն, դա նշանակում է, որ բառը պոլինդրոմ չէ։ Հակառակ դեպքում այն պոլինդրոմ է։

Իհարկե, այս տարբերակի վրա կարող ենք որոշակի փոփոխություններ կատարել, որոնք կարող են կոդը ավելի քիչ դարձնել, իսկ ալգորիթմը ավելի օպտիմալ։

Սակայն եկեք դիտարկենք լուծման այլ տարբերակ։

Կոդը տեղադրված է այս հղման մեջ

Ինչպես արդեն նշեցի, մենք պետք է ստուգենք տրված բառի առաջին մասը երկրորդ մասի հետ։ Այսինքն for loop֊ը կարող ենք իրականացնել բառի երկարության կեսի չափով (str.length/2): Որպեսզի կոդը ավելի պարզ լինի, ես charFromFirstHalf֊ին վերագրում եմ բառի առաջին կեսից վերցրած հերթական տառը, իսկ charFromSecondHalf֊ին վերագրում եմ բառի երկրորդ կեսից նրան համապատասխանող տառը։ Այդ տառերը toLowercase() մեթոդի միջոցով կդարձնենք փոքրատառ, քանի որ տառերի համեմատություն անելիս համեմատվում են տառերի ASCII կոդերը, որոնք ամեն սիմվոլի համար տարբեր են (օր․ "A" տառի ASCII կոդը 65 է իսկ "a" տառինը 97):
Քանի որ կոդը JavaSript լեզվով է և այստեղ զանգվածի ինդեքսավորումը սկսվում է 0֊ից, հետևաբար զանգվածի երկարության և զանգվածի վեջին էլեմենտի ինդեքսի թվերը իրարից 1֊ով տարբերվում են։ Այդ պատճառով երկրորդ կեսից համապատասխան ինդեքսը կվերցնեմ str.length-1-i ձևով։

Դե, ինչպես նշեցի, մեր վերցրած տառերը պիտի համեմատենք։ Եթե նրանք հավասար չեն, դա նշանակում է, որ բառը պոլինդրոմ չէ։ Տառերի հավասար չլինելու դեպքում կարող ենք ֆունկցիան դադարեցնել և վերադարձնել false արժեքը։

Հակառակ դեպքում, երբ բոլոր տարռերի զույգերը հավասար են, for loop֊ը հաջողությամբ կավարտվի և կանցնենք առաջ ու կվերադարձնենք true:

Այս նույն գաղափարը կարող ենք իրագործել նաև while֊ի օգնությամբ։ Այդ դեպքում մեր կոդը կունենա այս տեսքը։

Կոդը տեղադրված է այս հղման մեջ

Զանգվածից դուպլիկատներ հեռացնելու ալգորիթմներ

Arsen Mazmanyan — Sun, 14 Nov 2021 17:33:56 +0000

Բարև սիրելի ծրագրավորող (կամ ապագա ծրագրավորող)։

Այսօր կնայենք հարցազրույցների ժամանակ ամենատարածված խնդիրներից մեկը՝ տառերի զանգվածի միջից դուպլիկատների հեռացման խնդիրը և այդ խնդրի լուծման եղանակներից մի քանիսը։

Սակայն մինչև առաջ անցնելը 2 կարևոր բան
֊ Խնդիրների լուծումները կլինեն JavaScript լեզվով
֊ Ես ներկայացնում եմ խնդիրը լուծելու գաղափարները և չեմ բացատրելու, թե որ ֆունկցիան իրենից ինչ է ներկայացնում, սակայն կտեղադրեմ համապատասխան հղումները, որպեսզի դու ինքդ ուսումնասիրես

Բայց մինչև լուծման եղանակներին անցնելը, հասկանանք խնդիրը։
Մենք ստանալու ենք կամայական տառերի զանգված։ Որոշ տառեր կարող են կրկնվել։ Մեր խնդիրն է այնպես անել, որ ամեն տառից մնա 1 հատ։
Այսինքն եթե ստացել ենք ['a', 'a', 'b', 'c', 'd', 'a', 'b', 'a', 'y', 'y'] զանգվածը, պետք է վերադարձնենեք 'a', 'b', 'c', 'd', 'y' տառերը պարունակող զանգված (հերթականությունը էական չէ)։

Խնդիրը հասկացանք, հիմա անցնենք լուծման եղանակներին

Եղանակ 1

Առաջին եղանակը, որը կներկայացնեմ այն է, որ վերցնում ենք զանգվածի առաջին էլեմենտը և ստուգում, արդյո՞ք զանգվածում գոյություն ունի նույն էլեմենտից թե ոչ։ Եթե գոյություն ունի, ապա հեռացնում ենք գտած էլեմենտը, եթե ոչ, անցնում ենք առաջ։

Կոդը կունենա այսպիսի տեսք։

Վերցնում ենք առաջին էլեմենտը և այն ստուգում ենք զանգվածում իրենից հետո գտնվող մնացած էլեմենտների հետ և եթե նույն տարրից էլի կա, ապա գտածը հեռացնում ենք զանգվածից Array.splice() մեթոդի օգնությամբ։ Այստեղ պետք է մեր 2րդ ինդեքսը (j-ն) 1ով փոքրեցնենք, քանի որ զանգվածից 1 էլեմենտ հեռացնելուց հետո նշված ինդեքսից հետո գտնվող էլեմենտները վերադասավորվում են և բոլորի ինդեքսները 1ով փոքրանում են։ Այս գործողությունը անում ենք զանգվածի բոլոր էլեմենտների հետ։

Լուծման այս եղանակը մեր խնդրին բավարարում է։ Այն համապատասխանում է ES5֊ի ստանդարտներին։

Բայց արի այսքանով չսահմանափակվենք և դիտարկենք այլ տարբերակներ։

Եղանակ 2

Լուծման այս եղանակում կօգտագործենք forEach() և indexOf() մեթոդները, որպեսզի տեսնենք, արդյո՞ք նույն էլեմենտի էլի է հանդիպում զանգավծի մեջ թե ոչ։ Եթե ոչ, այն ավելացնում ենք մեր outputArr֊ի մեջ։

Եղանակ 3

Նախորդ եղանակը կարող ենք մի քիչ այլ ձևով իրականացնել։ Մեզ տրված զանգվածի մեջ դուպլիկատներ փնտրելու փոխարեն կարող ենք ստուգել, արդյո՞ք մեր outputArr֊ի մեջ արդեն կա այդ էլեմենտը թե ոչ։ Եթե չկա, ապա ավելացնում ենք։ Այս դեպքում, եթե զանգվածի մեջ դուպլիկատներ կան, ապա ավելի քիչ քայլ ենք անում, քան նախորդ դեպքում։

Եղանակ 4

Հիմա նայենք մեկ այլ լուծման եղանակի, որտեղ օգտագործվում է reduce մեթոդը։ Այս եղանակում ամեն տարրի համար ստուգում ենք, արդյո՞ք իրեն նախորդող տարրերի ենթաբազմությունում պարունակվում է իրեն հաջորդող տարրը թե ոչ։ Եթե ոչ, ապա ավելացնում ենք ստուգված էլեմենտը։ Սակայն այս դեպքում մենք ստանում ենք string տիպին համապատասխանող արժեք, որը կարող ենք զանգված դարձնել split() մեթոդի օգնությամբ։

Եղանակ 5

Իսկ հիմա քեզ ներկայացնեմ իմ ամենասիրած տարբերակը։ ES6-ում մենք ունենք Set օբյեկտը, որը իր մեջ պահում է միայն չկրկնվող էլեմենտներ։ Սակայն այն զանգված չի համարվում։ Սակայն մենք կարող ենք Set֊ի արժեքներից զանգված ստանալ Array.from() մեթոդի շնորհիվ։

Հույս ունեմ, այս նյութը քեզ օգնեց նոր գաղափարներ և նոր գիտելիք ստանալու հարցում։ Իսկ եթե ունես այնպիսի լուծման եղանակ, որը այստեղ նշված չէ, կարող ես ուղարկել ինձ, այդպիսով փորձի փոխանակում կանենք։

I'm not a Robot

Arsen Mazmanyan — Sun, 01 Aug 2021 19:39:38 +0000

If you're an active internet user then you've probably been accused of being a robot, at least once. It's known as CAPTCHA.

In this article, you'll learn about Captcha, what it is, why it is used and why it keeps changing.

Captcha was created in 2000 and stands for Completely Automatic Public Turing Test to Tell Computers and Humans Apart. Baiscally, it is a program that protects websites against bots by generating and grading tests that humans can pass but current computer programs cannot.

Captchas are being used for

protecting website registration
protecting online polls by stopping robots to send in repeated responses
stopping brute force attacks (where hackers/bots repeatedly try to log in using different passwords)
preventing users/hackers from signing up for multiple email accounts
stopping content spamming
...

Now let's talk about its history and development.

Back in 1990's people could write programs to sign up for millions of accounts. Those people were called spammers . Of course, tech companies needed a way to stop that. And that was one of the 10 Hardest Problems Yahoo Don't Know How To Solve.

Luis von Ahnwas (who is also co-founder and CEO of DuoLingo) was part of the CAPTCHA team. The team figured out that they need a test, which humans could pass, regardless of their age, education, etc.

In the main version of Captcha we were asked to read and type a distorted word from an image (things that humans could do but computers couldn't at that time).

But computers also had to be able to grade it. The solution was to put the right answer with the image into the database.

In 2005 a new version was released, called ReCaptcha.

This one used 2 words - the first one was a distorted text for which the computer had the right answer.
The second word was an image of a word from a book or an article. The computer didn't have the answer for the second word but if the user got the first word right, the computer assumed, that the second word is right as well and stored the data. The same image was used multiple times on different users and the most common answer was usually used as a right answer.

This all served as data, which helped computers to get smarter, smart enough to recognize letters and words from new images. In other words, we taught computers to read warped texts.

2014 Google computer learning study states, that a human could read most distorted CAPTHCAs with 33% accuracy. Meanwhile, their AI could do the same with ..... 99.8% accuracy. It's impressing, how we taught them to do something better than us, isn't it?

Since computers could do that better than humans, it was а time for а change.

The new version of ReCaptcha, ReCaptcha V2 was introduced in 2014, which featured images instead of distorted texts. The purpose is the same - to differentiate humans and computers.

And we are still helping computers to get smarter.

Most of the time we have to select cars, crossroads, and traffic lights from images. Google uses this data to improve its self-driving cars, so they can see those objects. Data is also used for improving Google Maps.

But as before, during the time computers become smarter and they can recognize items better than humans and the time for changes came again and this time ReCaptcha V3 was introduced.

There is not much that can be said for this one because it's a guarded secret. All we know is that our actions are being tracked from the minute we enter a website, which is using ReCaptcha V3. And by the time we click the submit button, we have already gotten our human badge (well, at least most of us, haha) and we don't need to find items from images.

Websites, that use ReCaptcha V3 have their benefits (more protected, clean from bots, etc) but we have to sacrifice our privacy to stay safe from bots and scams. Whether you want it or not, you are being tracked 90% of the time.

JavaScript in Game Development

Arsen Mazmanyan — Mon, 14 Jun 2021 07:22:51 +0000

When I meet someone and they ask what I do for job I tell them, that I'm a game developer. And here what happens. Either they think that I'm using C# and Unity ^[1] or they ask which technology/language I use. And when I tell them I'm using JavaScript for game development, they get confused, because lots of people think that JavaScript is used only for Front-end (React, Vue, Angular, ...) and Back-end (Node.js).

That's what pushed me into writing this article.

(Before you go ahead, I would like to inform you, that there will be nothing connected with code.)

Let's start with the definition of Game Development.

Game Development is the art of creating games and describes the design, development, and release of a game (We can call ourselves artists, isn't it interesting?).

Many game developers choose to develop games using different game engines, such as Unity, Unreal Engine, Gamemaker studio, Godot, etc. And the common languages for game development are C#, C++, Java, Python, Lua.

But only a few people know that you can make games using JS.

There are 2 main ways of making games with JS.
You can manipulate with DOM elements or you can use Canvas or WebGL.

As for me, making games with DOM elements is more of Web Development, and making games with Canvas/WebGL is more of Game Development.

Some of you may have heard of Canvas as an HTML5 element, but not about WebGL.

Let's go ahead and see what they are and what are their main differences.

The canvas element is part of HTML5 and allows for dynamic, scriptable rendering of 2D and 3D shapes and bitmap images. It is a low level, procedural model that updates a bitmap and does not have a built-in scene graph. It provides an empty graphic zone on which specific JavaScript APIs can draw.

Canvas API provides a means for drawing graphics using JS and the HTML canvas element. It can be used for animation, game graphics, data visualization, etc. Mainly focuses on 2D graphics.

WebGL is a JS API for rendering high-performance interactive 3D and 2D graphics within any compatible browser, without the use of plug-ins. WebGL does so by introducing an API that closely conforms to OpenGL ES 2.0 (cross-language, cross-platform Application Programming Interface) that can be used in HTML5 canvas elements. This conformance makes it possible for the API to take advantage of hardware graphics acceleration provided by the user's device.

Since both are JavaScript API’s, there will be similarities to some extent, especially if we talk about bindings and framework development.

WebGL and Canvas are HTML5 goodies. If a device supports WebGL, then it will automatically support Canvas, but nor Vice Versa^[2]. The native 3D API for WebGL is faster and has more capabilities like rendering pipelines, code accessibility, and faster execution.

Now you know what we need to use to make JS games. Let's go ahead and talk about what will help us to make games.

We can use either Game Engine or Game Framework to make games. (You can read about their differences in this article)

Some of the famous JavaScript Game Frameworks are
Phaser, Pixi.js, Three.js^[3], BabylonJS. But these are not the only ones.

These frameworks have lots of integrated tools, which will help you with your work but they also give you enough freedom, to create something on your own, to make it work the way you want. But you need to do more coding with that.

They all have their communities and there are many ways to join them, where you can ask your questions, get your answers, etc.

And last, but not least, they all have their tutorials, examples, and documentations very well organized, and using them you can start your journey in GameDev.

^[1] Unity supported JavaScript as a scripting language until 2017. It's not being supported since then.

^[2] Definition of vice versa - the other way around. With the order changed.

^[3] Three.js is often defined as 3D library because it doesn't provide some features that are needed to make games. But it doesn't mean you can't implement them.

Game Engines vs Game Frameworks

Arsen Mazmanyan — Fri, 11 Jun 2021 06:16:18 +0000

When people talk about Game Development, most of them think about Unity, Unreal Engine, or another famous Game Engine.

As for new developers, Game Engines are really great, because they are higher level, they include basic pieces to make games (graphics renderers, audio engines, ...). They have Level editors and Scene Graph (data structure, in which game data is stored in). Also, they do most of the 'dirty work' for you and in some cases, you can make a game without writing a single line of code (CopperCube engine). But it's not always a good idea to use a Game Engine for making games.

There are lots of games, that need their own logic, their own behavior, etc. And developers have 2 main choices. Either force tools to behave the way they need or create their own. (Actually, there is a 3rd option as well - quitting).

In cases, where they want to make something of their own, customized for themselves, Game Frameworks come in handy. Game Framework is a collection of libraries and tools. Libraries are usually created to solve a single task (such as physics, graphics, tweens, etc.).

Unlike Game Engines Game Frameworks make you code a lot. But it's a very good idea to use Game Framework if you want to practice coding.

And if you're experienced enough, you can bring together different tools and libraries (or create your own ones) and make something like Game Engine, from Game Framework.

Summing up, I will recommend Game Engine if it fits your need. Otherwise, I recommend Game Frameworks, because it will help you with coding practice and eventually will push you into creating something of your own (library, tool, or something like that).

Incognito - The Game of Words

Arsen Mazmanyan — Wed, 24 Feb 2021 18:05:22 +0000

I confirm, that the incognito mode on the browsers (well, at least on popular ones) is not what most of the people think it is. They still take a lot of data and we are not anonymous there.
But let's keep in order.

Most of us know about the incognito mode and most of us have used it at least once in our lives. I know only 4 browsers, that don't have incognito mode, but I'll talk about that later.

First of all let's check, how incognito is defined in Merriam-Webster (US most trusted online dictionary for English). It says "with one's identity concealed (adj.)".

In Wikipedia incognito mode is defined as 'When operating in such a mode, the browser creates a temporary session that is isolated from the browser's main session and user data'.

Everything seems fine so far. No lies. BUT

Researchers who cooperated with the University of Chicago and the Leibniz University of Hanover published the results of a study that included 450 participants. The topic was thoughts on 'Incognito mode' or 'Private mode'. According to the study

“46.5% of participants ‘believed bookmarks saved in private mode would not persist in later sessions,’ when they actually do.
“40.2% of participants thought websites would not be able to estimate a user’s location,” while in private mode. You can make it harder to estimate your location if you use a VPN.
“27.1% of participants believed private mode offered more protection against viruses and malware than standard [mode.]” This is a misconception since any files you download and open on your computer could still be infected with malware or viruses.
“22.0%, 37.0%, and 22.6% of participants mistakenly believed that ISPs, employers, and the government would be unable to track them when they used private mode.” If you’re on someone’s network, chances are they can see what you’re doing.

( https://www.cnbc.com/2018/07/12/private-web-browsing-not-as-private-as-you-think-research.html )

I personally find the problem in the definition of the word. We can say that some people still don't have enough knowledge and they expect way more than the usual 'Incognito mode' can provide. But we can also say 'Everybody lies', which we can see by reading the texts on 'Incognito mode' blank tabs. We can clearly see, that they are still far away from being real incognito.

According to DuckDuckGo, escaping the so-called ‘filter bubble’ of personalized online searches is a perniciously hard problem for the put upon Internet consumer who just wants to carve out a little unbiased space online, free from the suggestive taint of algorithmic fingers.

I won't go too deep into that, but if you're interested, here is the article (https://spreadprivacy.com/google-filter-bubble-study/). There they explain why they think so.

At the end, we can say that 'Incognito mode' is not what most of the people think it is. It still shows our activities to websites we visit, our internet providers (well, I hope only they get the info).

Wish you all a good day, have fun and be careful with your search history.