Linux-AWK/C2/MultiDimensional-Array-in-awk/Oriya

From Script | Spoken-Tutorial
Revision as of 12:04, 20 July 2019 by Pradeep (Talk | contribs)

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search
Time ' ' '
Narration
00:01 ବନ୍ଧୁଗଣ, AWK ଥିବା “ମଲ୍ଟିଡାଇମେନ୍ସନଲ୍ ଆରେ” ତିଆରି କରିବା ଉପରେ ଏହି ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲକୁ ସ୍ୱାଗତ
00:07 ଏହି ଟ୍ୟୁଟୋରିଆଲରେ ଆମେ - AWKରେ "ମଲ୍ଟି ଡାଇମେନ୍ସନଲ୍ ଆରେ” ତିଆରି କରିବା ଏବଂ "ମଲ୍ଟି ଡାଇମେନ୍ସନଲ୍ ଆରେ" ସ୍କାନ୍ କରିବା ବିଷୟରେ ଶିଖିବା
00:18 ଏହାକୁ ଆମେ କେତେକ ଉଦାହରଣ ମାଧ୍ୟମରେ କରିବା
00:21 ଏହି ଟ୍ୟୁଟୋରିଆଲ୍ ରେକର୍ଡ କରିବାକୁ ମୁଁ Ubuntu Linux 16.04 OS ଏବଂ Gedit Text Editor 3.20.1 ବ୍ୟବହାର କରୁଛି
00:33 ଆପଣ ନିଜ ପସନ୍ଦର Text Editor ବ୍ୟବହାର କରିପାରିବେ
00:37 ଏହି ଟ୍ୟୁଟୋରିଆଲ୍ ଅଭ୍ୟାସ କରିବା ପାଇଁ ଆପଣ, ଏହି ୱେବ୍ ସାଇଟ୍‌ରେ ଥିବା "ଆରେ” ଉପରେ ପୂର୍ବ AWK ଟ୍ୟୁଟୋରିଆଲଗୁଡ଼ିକ ବିଷୟରେ ଜାଣିଥିବା ଦରକାର
00:45 ଆପଣଙ୍କ ପାଖରେ C କିମ୍ୱା C++ ଭଳି ଯେକୌଣସି ପ୍ରୋଗ୍ରାମିଙ୍ଗ୍ ଲାଙ୍ଗୁଏଜ୍‌ର ମୌଳିକ ଜ୍ଞାନ ଥିବା ଉଚିତ
00:52 ଯଦି ନାହିଁ, ତେବେ ଆମ ୱେବ୍ ସାଇଟ୍‌ରେ ଥିବା ସମ୍ୱନ୍ଧିତ ଟ୍ୟୁଟୋରିଆଲଗୁଡ଼ିକୁ ଦେଖନ୍ତୁ
00:58 ଏହି ଟ୍ୟୁଟୋରିଆଲ୍ ପେଜ୍‌ରେ ଥିବା Code Files ଲିଙ୍କରେ ଏହି ଟ୍ୟୁଟୋରିଆଲରେ ବ୍ୟବହୃତ ଫାଇଲ୍‌ଗୁଡ଼ିକ ଉପଲବ୍ଧ ଅଛି.

ଦୟାକରି ସେଗୁଡ଼ିକୁ ଡାଉନଲୋଡ୍ କରି ଏକ୍ସଟ୍ରାକ୍ଟ କରନ୍ତୁ

01:08 AWKରେ ଏକ “ମଲ୍ଟିଡାଇମେନ୍ସନଲ୍ ଆରେ” କ’ଣ?
01:12 ଆମେ ଜାଣିଛେ ଯେ, "ସିଙ୍ଗଲ୍ ଡାଇମେନ୍ସନଲ୍ ଆରେଗୁଡ଼ିକ"ରେ ଏକ ସିଙ୍ଗଲ୍ "ଇଣ୍ଡେକ୍ସ” ଦ୍ୱାରା "ଆରେ ଏଲେମେଣ୍ଟ"କୁ ଚିହ୍ନଟ କରାଯାଇଥାଏ
01:19 ଉଦାହରଣସ୍ୱରୂପ, "ଆରେ ୱିକ୍"କୁ ଏକ ସିଙ୍ଗଲ୍ "ଇଣ୍ଡେକ୍ସ, Day” ଦ୍ୱାରା "ଚିହ୍ନଟ” କରାଯାଇଥାଏ
01:26 ହେଲେ, "ମଲ୍ଟି ଡାଇମେନ୍ସନଲ୍ ଆରେ"ରେ, ଏକାଧିକ "ଇଣ୍ଡାଇସେସ୍”ର ଏକ ଶୃଙ୍ଖଳା ଦ୍ୱାରା ଏକ “ଏଲେମେଣ୍ଟ”କୁ ଚିହ୍ନଟ କରାଯାଏ
01:34 ଉଦାହରଣସ୍ୱରୂପ, ଏକ "ଟୁ ଡାଇମେନ୍ସନଲ୍ ଆରେ ଏଲେମେଣ୍ଟ"କୁ “2 ଇଣ୍ଡାଇସେସ୍”ର ଶୃଙ୍ଖଳା ଦ୍ୱାରା ଚିହ୍ନଟ କରାଯାଏ
01:42 ଏଠାରେ, ଗୋଟିଏ ସିଙ୍ଗଲ୍ ଷ୍ଟ୍ରିଙ୍ଗରେ "ମଲ୍ଟିପଲ୍ ଇଣ୍ଡାଇସେସ୍", ସେଗୁଡ଼ିକ ମଧ୍ୟରେ ଏକ ସେପାରେଟର୍ ଦେଇ କନକାଟେନେଟ୍ କରାଯାଇଛି.
01:50 "ବିଲ୍ଟ-ଇନ୍ ଭେରିଏବଲ୍ SUBSEP”ର ମୂଲ୍ୟ ହେଉଛି "ସେପାରେଟର୍”
01:55 ଏକ ସରଳ "ୱନ୍ ଡାଇମେନ୍ସନଲ୍ ଆରେ” ପାଇଁ ଗୋଟିଏ ସିଙ୍ଗଲ୍ "ଇଣ୍ଡେକ୍ସ” ଭାବରେ ମିଶ୍ରିତ "ଷ୍ଟ୍ରିଙ୍ଗ୍” ବ୍ୟବହୃତ ହୋଇଥାଏ
02:01 ଉଦାହରଣସ୍ୱରୂପ, ମନେକରନ୍ତୁ ଆମେ “multi ସ୍କ୍ୱେର୍ ବ୍ରାକେଟ୍ସ ମଧ୍ୟରେ 4 କମା 6 ଇକ୍ୱାଲ୍ ଟୁ ଡବଲ୍ କୋଟ୍ସରେ ଭାଲ୍ୟୁ” ଲେଖିଲେ
02:11 ଏଠାରେ, multi ହେଉଛି multi-dimensional arrayର ନାମ “

ତା’ପରେ, ନମ୍ୱର୍ 4 ଓ 6 ଏକ "ଷ୍ଟ୍ରିଙ୍ଗ୍"ରେ ପରିବର୍ତ୍ତିତ ହୋଇଥାଏ

02:21 ମନେକରନ୍ତୁ, SUBSEPର ଭାଲ୍ୟୁ ହେଉଛି "ହାଶ ଚିହ୍ନ (#)”
02:26 ତା’ପରେ, ସେଗୁଡ଼ିକ ମଝିରେ ଏକ "ହାଶ୍ ଚିହ୍ନ (#)” ସହିତ ସେହି ନମ୍ୱର୍ ଗୁଡ଼ିକୁ କନକାଟେନେଟ୍ କରାଯାଇଛି
02:32 ତେଣୁ, “array element multi ସ୍କ୍ୱେର୍ ବ୍ରାକେଟ୍ ମଧ୍ୟରେ ଡବଲ୍ କୋଟ୍ସ ମଧ୍ୟରେ 4 ହାଶ୍ 6"କୁ "ଡବଲ୍ କୋଟ୍ସ ମଧ୍ୟରେ ଭାଲ୍ୟୁ"ରେ ସେଟ୍ କରାଗଲା
02:43 SUBSEPର ଡିଫଲ୍ଟ ଭାଲ୍ୟୁ ହେଉଛି "ଷ୍ଟ୍ରିଙ୍ଗ୍ ଡବଲ୍ କୋଟ୍ସ ମଧ୍ୟରେ ବେକ୍ ସ୍ଲାଶ୍ 034”
02:50 ଏହା ବାସ୍ତବରେ ଏକ "ନନ୍ ପ୍ରିଣ୍ଟିଙ୍ଗ୍ କ୍ୟାରେକ୍ଟର୍” ଅଟେ “

ଏହା ସାଧାରଣତଃ ଅଧିକାଂଶ ଇନପୁଟ୍ ଡେଟାରେ ଦେଖାଦିଏ ନାହିଁ

02:58 ସ୍ଲାଇଡ୍‌ରେ ଦେଖାଯାଇଥିବା ଭଳି ଚାଲନ୍ତୁ ଏକ "ଟୁ ଡାଇମେନ୍ସନଲ୍ ଆରେ” ଘୋଷଣା କରିବାକୁ ଚେଷ୍ଟା କରିବା
03:03 ଧାଡ଼ି 1ରେ ଦୁଇଟି ଏଲେମେଣ୍ଟ A ଓ B ଅଛି
03:08 ଧାଡ଼ି 2ରେ ଦୁଇଟି ଏଲେମେଣ୍ଟ C ଓ D ଅଛି
03:12 Ctrl, Alt ଓ T କୀ’ ଦାବି ଟର୍ମିନଲ୍ ଖୋଲନ୍ତୁ
03:17 cd କମାଣ୍ଡ ବ୍ୟବହାର କରି Code Files ଡାଉନଲୋଡ୍ ଓ ଏକ୍ସଟ୍ରାକ୍ଟ କରିଥିବା ଫୋଲ୍ଡର୍‌କୁ ଯାଆନ୍ତୁ
03:24 ଏବେ, ନିମ୍ନାନୁସାରେ "ଆରେ"କୁ ପରିଭାଷିତ କରନ୍ତୁ. ଏଠାରେ ଦେଖାଯାଇଥିବା ଭଳି କମାଣ୍ଡ ଟାଇପ୍ କରନ୍ତୁ

ତା’ପରେ Enter ଦାବନ୍ତୁ

03:35 କୌଣସି "ଏରର୍” ବିନା ଆମେ ଏକ "କମାଣ୍ଡ ପ୍ରମ୍ପ୍ଟ” ପାଇଲେ.

ତେଣୁ, "ଆରେ"ଟି ପରିଭାଷିତ ହେଲା

03:41 ଆମେ କୌଣସି ଆଉଟପୁଟ୍ ପାଇଲେ ନାହିଁ, କାରଣ କୋଡ୍‌ରେ ଆମେ କିଛି ବି ପ୍ରିଣ୍ଟ କରିବାକୁ ଦେଇନାହେଁ
03:47 ଚାଲନ୍ତୁ "ପ୍ରିଣ୍ଟ ଷ୍ଟେଟମେଣ୍ଟ” ଦେବା
03:50 ଟର୍ମିନଲ୍‌ରେ ପୂର୍ବ ନିଷ୍ପାଦିତ କମାଣ୍ଡକୁ ପାଇବା ପାଇଁ ଅପ୍ ଆରୋ କୀ’ ଦାବନ୍ତୁ
03:56 ବନ୍ଦ "କର୍ଲୀ ବ୍ରାକେଟ୍” ଠିକ୍ ପୂର୍ବରୁ ଟାଇପ୍ କରନ୍ତୁ, semicolon ସ୍ପେସ୍ print ସ୍ପେସ୍ a ସ୍କ୍ୱେର୍ ବ୍ରାକେଟ୍ସ ମଧ୍ୟରେ 2 କମା 2 .

କମାଣ୍ଡକୁ ନିଷ୍ପାଦନ କରିବା ପାଇଁ Enter ଦାବନ୍ତୁ

04:13 ଧ୍ୟାନ ଦିଅନ୍ତୁ ଯେ, ଆମକୁ କ୍ୟାପିଟଲ୍ D ଭାବେ ଆଉଟପୁଟ୍ ମିଳିଲା
04:18 ପ୍ରଦତ୍ତ "ମଲ୍ଟିଡାଇମେନ୍ସନଲ୍ ଆରେ"ରେ ଏକ ନିର୍ଦ୍ଦିଷ୍ଟ "ଇଣ୍ଡେକ୍ସ ସିକ୍ୱେନ୍ସ” ଅଛି କି ନାହିଁ କିପରି ଭାବେ ପରୀକ୍ଷା କରିବା?
04:25 ଆମେ, in operator ବ୍ୟବହାର କରିପାରିବା
04:28 ଏହାକୁ ଆମେ, ଏହି ଶୃଙ୍ଖଳାର ପୂର୍ବବର୍ତ୍ତୀ "ସିଙ୍ଗଲ୍ ଡାଇମେନ୍ସନଲ୍ ଆରେ”ରେ ଦେଖିସାରିଛେ
04:34 "କମା” ଦ୍ୱାରା ପୃଥକ୍ କରାଯାଇଥିବା ଏବଂ ପାରାନ୍ଥେସେସ୍ ମଧ୍ୟରେ ଥିବା "ଇଣ୍ଡାଇସେସ୍"ର ସମଗ୍ର ଶୃଙ୍ଖଳାକୁ ଆମକୁ ଲେଖିବାକୁ ହେବ
04:42 ଚାଲନ୍ତୁ ଏହାକୁ ଏକ ଉଦାହରଣରେ ଦେଖିବା
04:45 ମୁଁ, test_multi.awk ନାମକ ଗୋଟିଏ ସ୍କ୍ରିପ୍ଟ ଆଗରୁ ଲେଖିସାରିଛି
04:51 ଏହି ଟ୍ୟୁଟୋରିଆଲ୍ ପେଜ୍‌ର "କୋଡ୍ ଫାଇଲ୍ସ” ଲିଙ୍କରେ ସେହି ଫାଇଲ୍ ଉପଲବ୍ଧ ଅଛି
04:56 ଆମର ପୂର୍ବ ଆଲୋଚନାରେ ଯେପରି ଦେଖିଥିଲେ, ମୁଁ ଗୋଟିଏ “2 ବାଏ 2 ଆରେ” ପରିଭାଷିତ କରିଛି
05:02 ତା’ପରେ, ମୁଁ ଦୁଇଟି if conditions ଲେଖିଛି
05:06 "ଇଣ୍ଡେକ୍ସ ୱନ୍ କମା ୱନ୍"ରେ "ଏଲେମେଣ୍ଟ” ଉପସ୍ଥିତ ଅଛି କି ନାହିଁ, ତାହା ପ୍ରଥମ “if condition” ଯାଞ୍ଚ କରିଥାଏ
05:13 ଆମକୁ, "ପାରାନ୍ଥେସେସ୍” ମଧ୍ୟରେ "ମଲ୍ଟିଡାଇମେନ୍ସନଲ୍ ଆରେ” ପାଇଁ "ଇଣ୍ଡେକ୍ସ” ଲେଖିବାକୁ ହେବ
05:18 ଯଦି "କଣ୍ଡିଶନ୍” ସତ୍ୟ ହୋଇଥିବ, ତେବେ ଏହା one comma one is present ପ୍ରିଣ୍ଟ କରିବ
05:23 ଅନ୍ୟଥା, one comma one is absent ପ୍ରିଣ୍ଟ ହେବ
05:28 ସମାନ ଭାବରେ, Index three Comma Oneଠାରେ ଆମେ "ଏଲେମେଣ୍ଟ"ର ଉପସ୍ଥିତି ଯାଞ୍ଚ କରିବା.

ଫାଇଲ୍‌କୁ ନିଷ୍ପାଦନ କରନ୍ତୁ

05:36 ଟର୍ମିନଲ୍‌କୁ ଯାଆନ୍ତୁ ଏବଂ ଟାଇପ୍ କରନ୍ତୁ awk ସ୍ପେସ୍ ହାଇଫେନ୍ ସ୍ମଲ୍ f ସ୍ପେସ୍ test ଅଣ୍ଡରସ୍କୋର୍ multi ଡଟ୍ awk ଏବଂ Enter ଦାବନ୍ତୁ.
05:49 ଆଉଟପୁଟ୍ କୁହେ, One Comma One is Present ଏବଂ Three Comma One is Absent
05:55 ଚାଲନ୍ତୁ ଆଉ ଗୋଟିଏ ଉଦାହରଣ ଦେଖିବା.

ମନେକରନ୍ତୁ, ଆମେ ଗୋଟିଏ "ମେଟ୍ରିକ୍ସ"ର Transpose ତିଆରି କରିବାକୁ ଚାହୁଁଛେ

06:02 ପ୍ରଦତ୍ତ "ମେଟ୍ରିକ୍ସ"ର "ଟ୍ରାନ୍ସପୋଜ୍", ଗୋଟିଏ "ମେଟ୍ରିକ୍ସ"ର "ରୋ” ଓ "କଲମ୍"କୁ ଅନ୍ତଃପରିବର୍ତ୍ତନ କରାଯାଇ ଗଠନ କରାଯାଇଛି.

ଏହାକୁ ଆମେ କିପରି କରିବା?

06:11 2D-array.txt ଫାଇଲ୍‌ରେ ମୁଁ ଗୋଟିଏ "ଟୁ-ଡାଇମେନ୍ସନଲ୍ ଆରେ ମେଟ୍ରିକ୍ସ” ତିଆରି କରିଛି
06:19 ମୁଁ, transpose.awk ନାମକ ଗୋଟିଏ କୋଡ୍ ଲେଖିସାରିଛି
06:24 ପ୍ରଥମେ, ଏହି awk scriptର action sectionକୁ ଦେଖନ୍ତୁ
06:29 ଏଠାରେ ଆମେ, ଗୋଟିଏ "ରୋ"ରେ ଥିବା "ଫିଲ୍ଡ"ଗୁଡ଼ିକର ସର୍ବାଧିକ ସଂଖ୍ୟାକୁ ଗଣନା କରିବା

ଏବଂ ଗଣନା କରାଯାଇଥିବା ଭାଲ୍ୟୁକୁ Variable max_nfରେ ଷ୍ଟୋର୍ କରିବା

06:40 ଆମେ ଯେପରି ଜାଣିଛେ, awk ଦ୍ୱାରା ପ୍ରୋସେସ୍ କରାଯାଇଥିବା ସାମ୍ପ୍ରତିକ "ରେକର୍ଡସ୍"ର ନମ୍ୱର୍ ହେଉଛି NR.

Max_nr variableରେ NRର ଭାଲ୍ୟୁ ଷ୍ଟୋର୍ କରାଯାଇଛି

06:50 ପ୍ରଥମ "ରେକର୍ଡ"ରୁ ଶେଷ "ରେକର୍ଡ” ପର୍ଯ୍ୟନ୍ତ "ଇନପୁଟ୍ ଫାଇଲ୍"କୁ AWK ପ୍ରୋସେସ୍ କରିବ
06:56 AWK, ପ୍ରଥମ "ରେକର୍ଡ” ପ୍ରୋସେସ୍ କରିବାବେଳେ max_nr, 1 ସହିତ ସମାନ ରହିବ
07:03 ଦ୍ୱିତୀୟ "ରେକର୍ଡ” ପ୍ରୋସେସ୍ କରିବାବେଳେ max_nr, 2 ରହିବ ଏବଂ ଏହିଭଳି ଭାବରେ ଜାରି ରହିବ
07:11 ଯେତେବେଳେ AWK ଶେଷ "ରେକର୍ଡ” ପ୍ରୋସେସ୍ କରିବ max_nr, "ରେକର୍ଡ"ଗୁଡ଼ିକର ସମୁଦାୟ ସଂଖ୍ୟାକୁ ଷ୍ଟୋର୍ କରିବ
07:19 ଏବେ ଆମେ, "ଇନପୁଟ ଫାଇଲ୍"ରୁ ଡେଟା ପଢ଼ିବା ଏବଂ ତାହାକୁ "ଟୁ ଡାଇମେନ୍ସନଲ୍ ଆରେ"ରେ ଷ୍ଟୋର୍ କରିବା
07:26 For Loop ଭିତରେ, ଆମ ପାଖରେ Iterator Variable X ଅଛି
07:31 x, ୱନ୍ ରୁ NF ପର୍ଯ୍ୟନ୍ତ ପାର୍ କରିବ ଏବଂ ପ୍ରତ୍ୟେକ "ଆଇଟିରେଶନ୍” ପରେ x, 1 ଦ୍ୱାରା ବର୍ଦ୍ଧିତ ହେବ
07:39 xର ପ୍ରତ୍ୟେକ ଭାଲ୍ୟୁ ପାଇଁ $x (ଡଲର୍ x), ଫିଲ୍ଡ xଠାରେ ଭାଲ୍ୟୁକୁ ପ୍ରତିନିଧିତ୍ୱ କରିଥାଏ
07:46 ସେହି ଭାଲ୍ୟୁ, Index NR କମା xଠାରେ "ଆରେ ମେଟ୍ରିକ୍ସ"ରେ ଷ୍ଟୋର୍ ହେବ
07:53 ଉଦାହରଣସ୍ୱରୂପ, "ଇନପୁଟ୍ ଫାଇଲ୍"ରୁ "ଇଣ୍ଡେକ୍ସ 1 କମା 1"ରେ ଉପସ୍ଥିତ ଥିବା ଭାଲ୍ୟୁକୁ "Matrix of 1 comma 1” ଷ୍ଟୋର୍ କରିଥାଏ
08:02 ତେଣୁ, ଏହି କୋଡ୍ ସହିତ ସମଗ୍ର "ଇନପୁଟ୍ ଫାଇଲ୍”କୁ AWK ପ୍ରୋସେସ୍ କରିବା ପରେ, "ମେଟ୍ରିକ୍ସ ଆରେ: ସମ୍ପୂର୍ଣ୍ଣ ଭାବେ ଗଠିତ ହୋଇଯିବ
08:10 ଏହା, "ଇନପୁଟ୍ ଫାଇଲ୍"ର ସମଗ୍ର ଡେଟାକୁ ଏକ "ଟୁ ଡାଇମେନ୍ସନଲ୍ ଆରେ” ଫର୍ମାଟ୍‌ରେ ଷ୍ଟୋର୍ କରିଦେବ
08:16 ଏବେ ଚାଲନ୍ତୁ, END Section ଭିତରେ ଦେଖିବା
08:20 Matrixର Transpose ପ୍ରିଣ୍ଟ କରିବା ପାଇଁ ଆମେ ଏକ Nested For Loop ଲେଖିଛେ
08:25 ମୁଁ, ବେସିକ୍ C ପ୍ରୋଗ୍ରାମିଙ୍ଗ୍ ସହିତ ଆପଣଙ୍କ ପରିଚିତତାକୁ କଳ୍ପନା କରିପାରୁଛି.

ତେଣୁ, କୋଡ୍‌ର ଏହି ଭାଗକୁ ସବିଶେଷ ବର୍ଣ୍ଣନା କରୁନାହିଁ

08:34 ଏଠାରେ କୋଡ୍‌କୁ ସବିଶେଷରେ ଦେଖିବା ପାଇଁ ଭିଡିଓକୁ ପଜ୍ କରନ୍ତୁ ଏବଂ ନିଜେ ବୁଝନ୍ତୁ
08:40 ଏବେ, ଏକ "ମଲ୍ଟିଡାଇମେନ୍ସନଲ୍ ଆରେ"କୁ ସ୍କାନ୍ କରିବା ବିଷୟରେ ଶିଖିବା
08:45 ଯଥାର୍ଥ ଅର୍ଥରେ AWK ପାଖରେ ଏକ "ମଲ୍ଟି-ଡାଇମେନ୍ସନଲ୍ ଆରେ” ନଥାଏ
08:50 ତେଣୁ, "ମଲ୍ଟି ଡାଇମେନ୍ସନଲ୍ ଆରେ" ସ୍କାନ୍ କରିବା ପାଇଁ କୌଣସି ବିଶେଷ For Statement ନାହିଁ
08:56 ଗୋଟିଏ "ଆରେ” ସ୍କାନ୍ କରିବା ପାଇଁ ଆପଣ "ମଲ୍ଟିଡାଇମେନ୍ସନଲ୍” ମାର୍ଗ ରଖିପାରିବେ
09:00 ଏହାପାଇଁ ଆପଣ, Split Function ସହିତ For Statementକୁ ମିଶାଇପାରିବେ
09:05 Split Function କ’ଣ, ଚାଲନ୍ତୁ ଦେଖିବା.

ଗୋଟିଏ "ଷ୍ଟ୍ରିଙ୍ଗ୍"କୁ ଖଣ୍ଡ ଖଣ୍ଡ କରି କାଟିବା ବା Split କରିବା ପାଇଁ Split Function ବ୍ୟବହୃତ ହୋଇଥାଏ

09:14 ଏବଂ ବିଭିନ୍ନ ଖଣ୍ଡକୁ ଏକ "ଆରେ"ରେ ରଖିଥାଏ
09:18 ସିଣ୍ଟାକ୍ସ ନିମ୍ନରେ ଦିଆଯାଇଛି. କାଟିବା ପାଇଁ "ଷ୍ଟ୍ରିଙ୍ଗ୍" ପ୍ରଥମ "ଆର୍ଗୁମେଣ୍ଟ"ରେ ଅଛି
09:25 କଟାଯାଇଥିବା ଖଣ୍ଡକୁ Split କେଉଁଠାରେ ରଖିବ, ସେହି "ଆରେ"ର ନାମ ଦ୍ୱିତୀୟ "ଆର୍ଗୁମେଣ୍ଟ” ନିର୍ଦ୍ଦିଷ୍ଟ କରିଥାଏ
09:33 "ଷ୍ଟ୍ରିଙ୍ଗ୍"କୁ କାଟିବା ପାଇଁ ବ୍ୟବହୃତ "ସେପାରେଟର୍” ବିଷୟରେ ତୃତୀୟ "ଆର୍ଗୁମେଣ୍ଟ” ଉଲ୍ଲେଖ କରିଥାଏ
09:39 ପ୍ରଥମ ଖଣ୍ଡକୁ arr 1ରେ ଷ୍ଟୋର୍ କରାଗଲା
09:43 ଦ୍ୱିତୀୟ ଖଣ୍ଡକୁ arr 2ରେ ଏବଂ ଏହିଭଳି ଭାବେ
09:48 ମନେକରନ୍ତୁ, ପୂର୍ବରୁ ତିଆରି କରାଯାଇଥିବା ଏକ "ଆରେ"ରୁ "ଇଣ୍ଡାଇସେସ୍"ର ମୂଳ ଶୃଙ୍ଖଳାକୁ ଆମେ ରିକଭର୍ କରିବାକୁ ଚାହୁଁଛେ.

ଏହାକୁ ଆମେ କିପରି କରିବା?

09:56 ମୁଁ, multi_scan.awk ନାମକ ଗୋଟିଏ କୋଡ୍ ଲେଖିସାରିଛି
10:02 BEGIN Section ଭିତରେ ସମଗ୍ର କୋଡ୍ ଲେଖାଯାଇଛି
10:06 ପ୍ରଥମେ ଆମେ, a ନାମକ ଏକ "ଆରେ” ତିଆରି କଲେ ଏବଂ ସେଥିରେ ଏହିସବୁ ଭାଲ୍ୟୁ ଆସାଇନ୍ କଲେ
10:12 ତା’ପରେ ଆମେ, ଏକ "ଆଇଟିରେଟର୍” ସହ For Loop ରଖିଲେ
10:16 ପ୍ରତ୍ୟେକ "ଆଇଟିରେଶନ୍” ପାଇଁ ପ୍ରତ୍ୟେକ "ଇଣ୍ଡାଇସେସ୍ ଭାଲ୍ୟୁ"କୁ ସେଟ୍ କରାଯିବ.

ମନେକରନ୍ତୁ 1,1 - ତା’ପରେ 1,2 ଏବଂ ଏହିଭଳି ଭାବେ

10:27 Split Function, "ଆଇଟିରେଟର୍"କୁ ଖଣ୍ଡ ଖଣ୍ଡ କରିବ, ଯାହା SUBSEP ଦ୍ୱାରା ପୃଥକ୍ କରାଯିବ
10:34 ସେହି ଖଣ୍ଡଗୁଡ଼ିକ array arrରେ ଷ୍ଟୋର୍ କରାଯିବ
10:38 ତେଣୁ, arr[1] ଓ arr[2],କ୍ରମଶଃ ପ୍ରଥମ "ଇଣ୍ଡେକ୍ସ” ଓ ଦ୍ୱିତୀୟ "ଇଣ୍ଡେକ୍ସ"କୁ ରଖିବେ.

ଫାଇଲ୍‌କୁ ନିଷ୍ପାଦନ କରନ୍ତୁ

10:48 ଟର୍ମିନଲ୍‌କୁ ଯାଆନ୍ତୁ ଏବଂ ଟାଇପ୍ କରନ୍ତୁ awk ସ୍ପେସ୍ ହାଇଫେନ୍ ସ୍ମଲ୍ f ସ୍ପେସ୍ multi ଅଣ୍ଡରସ୍କୋର୍ scan ଡଟ୍ awk

ଏବଂ Enter ଦାବନ୍ତୁ

11:01 ଆଉଟପୁଟ୍ ଦେଖନ୍ତୁ; "ଇଣ୍ଡାଇସେସ୍"ର ମୂଳ ଶୃଙ୍ଖଳା ରିକଭର୍ ହୋଇଗଲା
11:07 ସଂକ୍ଷିପ୍ତରେ - ଏହି ଟ୍ୟୁଟୋରିଆଲରେ ଆମେ - AWKରେ "ମଲ୍ଟି ଡାଇମେନ୍ସନଲ୍ ଆରେ” ତିଆରି କରିବା ଏବଂ "ମଲ୍ଟି ଡାଇମେନ୍ସନଲ୍ ଆରେ" ସ୍କାନ୍ କରିବା ବିଷୟରେ ଶିଖିଲେ
11:18 ଏକ ଆସାଇନମେଣ୍ଟ ଭାବେ, ଗୋଟିଏ "ଟୁ ଡାଇମେନ୍ସନଲ୍ ଆରେ"କୁ 90 ଡିଗ୍ରୀ ଘୂରାଇବା ପାଇଁ ଏକ awk script ଲେଖନ୍ତୁ ଏବଂ ଘୂରିଥିବା "ମେଟ୍ରିକ୍ସ"କୁ ପ୍ରିଣ୍ଟ କରନ୍ତୁ
11:28 ନିମ୍ନ ଲିଙ୍କରେ ଉପଲବ୍ଧ ଭିଡିଓ ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲ୍ ପ୍ରୋଜେକ୍ଟକୁ ସାରାଂଶିତ କରେ.

ଦୟାକରି ଏହାକୁ ଡାଉନଲୋଡ୍ କରି ଦେଖନ୍ତୁ

11:36 ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲ୍ ପ୍ରୋଜେକ୍ଟ ଟିମ୍, ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲ୍ସ ବ୍ୟବହାର କରି କର୍ମଶାଳାମାନ ଚଲାନ୍ତି

ଏବଂ ପ୍ରମାଣପତ୍ର ଦିଅନ୍ତି.

11:45 ଅଧିକ ବିବରଣୀ ପାଇଁ ଦୟାକରି ଆମକୁ ଲେଖନ୍ତୁ
11:49 ଦୟାକରି ଏହି ଫୋରମରେ ନିଜର ସମୟବଦ୍ଧ ପ୍ରଶ୍ନ ପୋଷ୍ଟ୍ କରନ୍ତୁ
11:53 ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆନ୍ ପ୍ରୋଜେକ୍ଟ, ଭାରତ ସରକାରଙ୍କ MHRDର NMEICT ଦ୍ୱାରା ଅନୁଦାନ ପ୍ରାପ୍ତ.

ଏହି ମିଶନ୍ ଉପରେ ଅଧିକ ବିବରଣୀ ନିମ୍ନ ଲିଙ୍କରେ ଉପଲବ୍ଧ

12:05 IIT Bombay ତରଫରୁ ମୁଁ ପ୍ରଦୀପ ଚନ୍ଦ୍ର ମହାପାତ୍ର ଆପଣଙ୍କଠାରୁ ବିଦାୟ ନେଉଛି.

ଆମ ସହିତ ଜଡ଼ିତ ହୋଇଥିବାରୁ, ଧନ୍ୟବାଦ

Contributors and Content Editors

PoojaMoolya, Pradeep