C හි, භාවිතා කිරීම ++iසහ අතර ඇති වෙනස කුමක්ද i++, සහ ලූපයක වර්ධක කොටසෙහි භාවිතා කළ යුත්තේ forකුමක්ද?

• ++iහි අගය වැඩි කරයි i, පසුව වැඩි කළ අගය නැවත ලබා දෙනු ඇත.

   i = 1;
   j = ++i;
   (i is 2, j is 2)

• i++හි අගය වැඩි කරනු ඇත i, නමුත් iවැඩි කිරීමට පෙර තිබූ මුල් අගය නැවත ලබා දෙනු ඇත .

   i = 1;
   j = i++;
   (i is 2, j is 1)

සඳහා forචක්රයකට ක්රියා එක්කෝ. ++iවඩාත් පොදු බවක් පෙනේ, සමහර විට එය K&R හි භාවිතා වන නිසා විය හැකිය .

ඕනෑම අවස්ථාවක, එම උපදෙස් මාලාවක් "කැමති අනුගමනය ++iපුරා i++" සහ ඔබ වැරදි යන්නේ නැහැ.

++iසහ කාර්යක්ෂමතාව පිළිබඳව අදහස් කිහිපයක් තිබේ i++. ඕනෑම ශිෂ්‍ය නොවන ව්‍යාපෘති සම්පාදකයෙකු තුළ, කාර්ය සාධන වෙනසක් නොමැත. උත්පාදනය කළ කේතය දෙස බැලීමෙන් ඔබට මෙය සත්‍යාපනය කළ හැකිය, එය සමාන වේ.

කාර්යක්ෂමතා ප්‍රශ්නය සිත්ගන්නා සුළුය ... මෙන්න පිළිතුරක් සඳහා මගේ උත්සාහය: C හි i ++ සහ ++ i අතර කාර්ය සාධන වෙනසක් තිබේද?

ලෙස @OnFreund සිට සටහන්, එය, එය C ++ වස්තුව සඳහා විවිධ වේ operator++()ශ්රිතයක් වේ හා සම්පාදකවරයා අතරමැදි අගය පැවැත්වීමට තාවකාලික වස්තුව නිර්මාණය ඉවතට උපරිම ඵල ලබා ගැනීම සඳහා දන්නේ නැහැ.

i ++ පශ්චාත් වර්ධක ලෙස හැඳින්වෙන අතර ++ i පෙර වර්ධක ලෙස හැඳින්වේ .

i++

i++පශ්චාත් වර්ධක වේ, මන්ද එය iමෙහෙයුම අවසන් වූ පසු එහි අගය 1 කින් වැඩි කරයි.

පහත උදාහරණය බලමු:

int i = 1, j;
j = i++;

මෙහි වටිනාකම j = 1නමුත් i = 2. මෙහි වටිනාකම පළමුව iපවරනු ලබන අතර jපසුව වැඩි iකරනු ලැබේ.

++i

++iපෙර වර්ධක වේ, මන්ද එය iමෙහෙයුමට පෙර එහි අගය 1 කින් වැඩි කරයි. එයින් අදහස් වන්නේ j = i;පසුව ක්‍රියාත්මක වනු ඇති i++බවයි.

පහත උදාහරණය බලමු:

int i = 1, j;
j = ++i;

මෙහි වටිනාකම j = 2නමුත් i = 2. වැඩි කිරීමෙන් පසු මෙහි අගය iපවරනු ලැබේ . ඒ හා සමානව මීට පෙර ක්‍රියාත්මක වේ.jii++ij=i;

For for loop හි වර්ධක කොටසෙහි භාවිතා කළ යුතු ඔබේ ප්‍රශ්නය සඳහා? පිළිතුර නම්, ඔබට ඕනෑම එකක් භාවිතා කළ හැකිය .. කමක් නැත. එය ඔබගේ for loop එකම අංකයකින් ක්‍රියාත්මක කරයි. වාර ගණන.

for(i=0; i<5; i++)
   printf("%d ",i);

සහ

for(i=0; i<5; ++i)
   printf("%d ",i);

ලූප දෙකම එකම ප්‍රතිදානයක් ලබා දෙනු ඇත. එනම් 0 1 2 3 4.

එය වැදගත් වන්නේ ඔබ එය භාවිතා කරන ස්ථානය පමණි.

for(i = 0; i<5;)
    printf("%d ",++i);

මෙම අවස්ථාවේ දී ප්‍රතිදානය වනු ඇත 1 2 3 4 5.

කරුණාකර වේගවත් වන “කාර්යක්ෂමතාව” (වේගය, ඇත්ත වශයෙන්ම) ගැන කරදර නොවන්න. මේ දේවල් ගැන සැලකිලිමත් වන සම්පාදකයන් මේ දිනවල අප සතුව ඇත. ඔබේ අභිප්‍රාය වඩාත් පැහැදිලිව පෙන්වන, භාවිතා කිරීමට තේරුමක් ඇති ඕනෑම දෙයක් භාවිතා කරන්න.

++i අගය වැඩි කරයි, පසුව එය ලබා දෙයි.

i++ අගය ආපසු ලබා දෙන අතර පසුව එය වැඩි කරයි.

එය සියුම් වෙනසක්.

ලූපයක් සඳහා ++i, එය තරමක් වේගවත් බැවින් භාවිතා කරන්න . i++ඉවතලන අමතර පිටපතක් සාදනු ඇත.

i++: මෙම තත්වය තුළ පළමුව අගය පවරා ඇති අතර පසුව වර්ධක සිදු වේ.

++i: මෙම අවස්ථාවෙහිදී පළමුව වර්ධකය සිදු කර පසුව අගය පවරනු ලැබේ

පහත දැක්වෙන්නේ රූප දෘශ්‍යකරණය වන අතර එය මනාව පෙන්වන ප්‍රායෝගික වීඩියෝවක් ද වේ.

හේතුව ++i හැකි වඩා තරමක් වේගවත් i++එනම් i++අතර, එය නිලධාරිෙයකු ලක්වෙයි පෙර මම වටිනාකම දේශීය පිටපතක් අවශ්ය හැක ++iකරන්නේ නැහැ. සමහර අවස්ථාවලදී, සමහර සම්පාදකයින් හැකි නම් එය ප්‍රශස්තිකරණය කරනු ඇත ... නමුත් එය සැමවිටම කළ නොහැකි අතර සියලුම සම්පාදකයින් මෙය නොකරයි.

මම සම්පාදක ප්‍රශස්තිකරණය මත වැඩිපුර රඳා නොසිටීමට උත්සාහ කරමි, එබැවින් මම රයන් ෆොක්ස්ගේ උපදෙස් අනුගමනය කරමි: මට මේ දෙකම භාවිතා කළ හැකි විට මම භාවිතා කරමි ++i.

එක්කෝ ලූපයක භාවිතා කිරීමේ result ලදායී ප්‍රති result ලය සමාන වේ. වෙනත් වචන වලින් කිවහොත්, ලූප් අවස්ථා දෙකේදීම එකම දේ කරයි.

කාර්යක්ෂමතාව සම්බන්ධයෙන් ගත් කල, i ++ ට වඩා ++ i තෝරාගැනීමේදී ද penalty ුවමක් තිබිය හැකිය. භාෂා පිරිවිතරයට අනුව, පශ්චාත් වර්ධක ක්‍රියාකරු භාවිතා කිරීමෙන් ක්‍රියාකරු ක්‍රියා කරන වටිනාකමේ අමතර පිටපතක් නිර්මාණය කළ යුතුය. මෙය අතිරේක මෙහෙයුම් වල ප්‍රභවයක් විය හැකිය.

කෙසේ වෙතත්, පෙර තර්කනයේ ප්‍රධාන ගැටළු දෙකක් ඔබ සලකා බැලිය යුතුය.

1. නවීන සම්පාදකයින් විශිෂ්ටයි. සියලු හොඳ සම්පාදකයින් එය ලූපයක් සඳහා පූර්ණ සංඛ්‍යා වර්ධකයක් දකින බව වටහා ගැනීමට තරම් බුද්ධිමත් වන අතර එය ක්‍රම දෙකම එකම කාර්යක්ෂම කේතයකට ප්‍රශස්තිකරණය කරනු ඇත. පූර්ව වර්ධකයට වඩා පශ්චාත් වර්ධක භාවිතා කිරීම ඇත්ත වශයෙන්ම ඔබේ වැඩසටහන මන්දගාමී ධාවන කාලයක් ලබා ගැනීමට හේතු වේ නම්, ඔබ භාවිතා කරන්නේ භයානක සම්පාදකයෙකි.

2. මෙහෙයුම් කාල-සංකීර්ණතාව අනුව, ක්‍රම දෙක (පිටපතක් ඇත්ත වශයෙන්ම සිදු වුවද) සමාන වේ. වර්ධක මෙහෙයුමේ මෙහෙයුම් ගණන සැලකිය යුතු ලෙස ආධිපත්‍යය දරයි. එබැවින්, සැලකිය යුතු ප්‍රමාණයේ ඕනෑම පුඩුවක් තුළ, වර්ධක ක්‍රමයේ ද penalty ුවම ලූප් ශරීරය ක්‍රියාත්මක කිරීමෙන් දැවැන්ත ලෙස යටපත් වේ. වෙනත් වචන වලින් කිවහොත්, වර්ධකයට වඩා ලූපයේ කේතය ප්‍රශස්තිකරණය කිරීම ගැන කරදර වීමට වඩා හොඳය.

මගේ මතය අනුව, සමස්ත ප්‍රශ්නයම විලාසිතාවේ මනාපයක් දක්වා තල්ලු වේ. පෙර වර්ධක කියවිය හැකි යැයි ඔබ සිතන්නේ නම්, එය භාවිතා කරන්න. පුද්ගලිකව, මම පශ්චාත්-ඇතුළත් කිරීම් වලට වැඩි කැමැත්තක් දක්වන්නෙමි, නමුත් එයට හේතුව ප්‍රශස්තිකරණය පිළිබඳ කිසිවක් දැන ගැනීමට පෙර එය මට ඉගැන්වූ නිසා විය හැකිය.

මෙය නොමේරූ ප්‍රශස්තිකරණය සඳහා ඉතා වැදගත් උදාහරණයකි, මෙවැනි ගැටළු වලට නිර්මාණයේ බරපතල ගැටළු වලින් අපව ract ත් කිරීමේ හැකියාව ඇත. කෙසේ වෙතත්, "හොඳම භාවිතයේ" භාවිතයේ ඒකාකාරී බවක් හෝ එකඟතාවයක් නොමැති නිසා එය ඇසීම තවමත් හොඳ ප්‍රශ්නයකි.

ඔවුන් දෙදෙනාම සංඛ්යාව වැඩි කරයි. ++iසමාන වේ i = i + 1.

i++හා ++iඉතා සමාන නමුත් හරියටම එම නැත. දෙකම අංකය වැඩි කරයි, නමුත් ++iවත්මන් ප්‍රකාශනය ඇගයීමට පෙර අංකය i++වැඩි කරන අතර ප්‍රකාශනය ඇගයීමෙන් පසු අංකය වැඩි කරයි.

උදාහරණයක්:

int i = 1;
int x = i++; //x is 1, i is 2
int y = ++i; //y is 3, i is 3

++i(උපසර්ගය මෙහෙයුම): වැටුප් වර්ධක සහ පසුව අගය පවරයි
(උදා:): int i = 5, int b = ++i මේ අවස්ථාවේ දී, 6 7 සහ එසේ මත පළමු හා පසුව වැටුප් වර්ධක b අනුයුක්ත කර ඇත.

i++(Postfix මෙහෙයුම): තං පසුව වටිනාකම වර්ධක
(උදා:): int i = 5, int b = i++ මේ අවස්ථාවේ දී, 5 6 සහ එසේ මත පළමු හා පසුව වැටුප් වර්ධක b අනුයුක්ත කර ඇත.

පුඩුවක් සඳහා විගමනික ශ්රමිකයින්: i++සාමාන්යයෙන් අප ආරම්භක අගය භාවිතා කරන්න, මන්ද බොහෝ දුරට භාවිතා iපුඩුවක් සඳහා incrementing පෙර. නමුත් ඔබේ වැඩසටහන් තර්කනය අනුව එය වෙනස් විය හැකිය.

++i: පූර්ව වර්ධකයක් වන අතර අනෙක පශ්චාත් වර්ධක වේ.

i++: මූලද්‍රව්‍යය ලබාගෙන එය වැඩි කරයි.
++i: වර්ධක i පසුව මූලද්‍රව්‍යය නැවත ලබා දෙයි.

උදාහරණයක්:

int i = 0;
printf("i: %d\n", i);
printf("i++: %d\n", i++);
printf("++i: %d\n", ++i);

ප්‍රතිදානය:

i: 0
i++: 0
++i: 2

අර්ථ නිරූපණයන්හි වෙනස ඔබ දැන් තේරුම් ගෙන ඇතැයි මම සිතමි. (අවංකවම මම කල්පනා කරන්නේ මිනිසුන් කියවීමට වඩා 'ක්‍රියාකරු X යන්නෙන් අදහස් කරන්නේ කුමක්ද' යන්නයි.

කෙසේ වෙතත්, කුමන එකක් භාවිතා කළ යුතුද යන්න, C ++ හි පවා වැදගත් නොවන කාර්ය සාධනය පිළිබඳ ප්‍රශ්න නොසලකා හරින්න. කුමන දේ භාවිතා කළ යුතුද යන්න තීරණය කිරීමේදී ඔබ භාවිතා කළ යුතු මූලධර්මය මෙයයි:

ඔබ කේතයෙන් අදහස් කරන දේ කියන්න.

ඔබේ ප්‍රකාශයේ අගය වැඩි කිරීමට පෙර ඔබට අවශ්‍ය නැතිනම්, ක්‍රියාකරුගේ එම ආකෘතිය භාවිතා නොකරන්න. එය සුළු කාරණයක්, නමුත් ඔබ එක් අනුවාදයක් අනෙකාට සම්පූර්ණයෙන්ම තහනම් කරන විලාසිතාවේ මාර්ගෝපදේශයක් සමඟ වැඩ නොකරන්නේ නම් (අස්ථි හිස සහිත ශෛලීය මාර්ගෝපදේශකය), ඔබ කිරීමට උත්සාහ කරන දේ වඩාත් නිවැරදිව ප්‍රකාශ කරන පෝරමය භාවිතා කළ යුතුය.

QED, පෙර වර්ධක අනුවාදය භාවිතා කරන්න:

for (int i = 0; i != X; ++i) ...

මෙම සරල C ++ කේතය මගින් වෙනස තේරුම් ගත හැකිය:

int i, j, k, l;
i = 1; //initialize int i with 1
j = i+1; //add 1 with i and set that as the value of j. i is still 1
k = i++; //k gets the current value of i, after that i is incremented. So here i is 2, but k is 1
l = ++i; // i is incremented first and then returned. So the value of i is 3 and so does l.
cout << i << ' ' << j << ' ' << k << ' '<< l << endl;
return 0;

ප්රධාන වෙනස වන්නේ

• i ++ පෝස්ට් (වැඩි කිරීමෙන් පසු ) සහ

• ++ i පෙර ( වැඩි කිරීමට පෙර )

  • i =1 ලූප් වර්ධක කැමති නම් පළ කරන්න1,2,3,4,n
  • පෙර i =1 ලූප වර්ධක වැනි නම්2,3,4,5,n

i ++ සහ ++ i

දැනටමත් පළ කර ඇති පිළිතුරු වලට වඩා වෙනස් කෝණයකින් වෙනස දෘශ්‍ය කිරීමට මෙම කුඩා කේතය උපකාරී වේ:

int i = 10, j = 10;
  
printf ("i is %i \n", i);
printf ("i++ is %i \n", i++);
printf ("i is %i \n\n", i);
  
printf ("j is %i \n", j);
printf ("++j is %i \n", ++j);
printf ("j is %i \n", j);

ප්‍රති come ලය:

//Remember that the values are i = 10, and j = 10

i is 10 
i++ is 10     //Assigns (print out), then increments
i is 11 

j is 10 
++j is 11    //Increments, then assigns (print out)
j is 11 

පෙර සහ පසු තත්වයන් කෙරෙහි අවධානය යොමු කරන්න.

ලූප් සඳහා

ෆෝ ලූපයක වර්ධක කොටසක ඒවායින් එකක් භාවිතා කළ යුතු යැයි මම සිතමි, තීරණයක් ගැනීමට අපට කළ හැකි හොඳම දේ හොඳ උදාහරණයක් භාවිතා කිරීම ය:

int i, j;

for (i = 0; i <= 3; i++)
    printf (" > iteration #%i", i);

printf ("\n");

for (j = 0; j <= 3; ++j)
    printf (" > iteration #%i", j);

ප්‍රති come ලය:

> iteration #0 > iteration #1 > iteration #2 > iteration #3
> iteration #0 > iteration #1 > iteration #2 > iteration #3 

මම ඔබ ගැන නොදනිමි, නමුත් එහි භාවිතයේ කිසිදු වෙනසක් මා දකින්නේ නැත, අවම වශයෙන් for for loop එකකවත්.

පහත දැක්වෙන සී කේත කැබැල්ල පෙර හා පසු වර්ධක සහ අඩු කිරීමේ ක්‍රියාකරුවන් අතර වෙනස විදහා දක්වයි:

int  i;
int  j;

වර්ධක ක්‍රියාකරුවන්:

i = 1;
j = ++i;    // i is now 2, j is also 2
j = i++;    // i is now 3, j is 2

පූර්ව-නිර්මාණය යනු එකම රේඛාවකින් වැඩි කිරීමයි. පශ්චාත් වර්ධක යනු රේඛාව ක්‍රියාත්මක වූ පසු වර්ධක යන්නයි.

int j=0;
System.out.println(j); //0
System.out.println(j++); //0. post-increment. It means after this line executes j increments.

int k=0;
System.out.println(k); //0
System.out.println(++k); //1. pre increment. It means it increments first and then the line executes

එය OR, සහ ක්‍රියාකරුවන් සමඟ පැමිණි විට එය වඩාත් සිත්ගන්නා සුළු වේ.

int m=0;
if((m == 0 || m++ == 0) && (m++ == 1)) { //false
/* in OR condition if first line is already true then compiler doesn't check the rest. It is technique of compiler optimization */
System.out.println("post-increment "+m);
}

int n=0;
if((n == 0 || n++ == 0) && (++n == 1)) { //true
System.out.println("pre-increment "+n); //1
}

අරාවේ

System.out.println("In Array");
int[] a = { 55, 11, 15, 20, 25 } ;
int ii, jj, kk = 1, mm;
ii = ++a[1]; // ii = 12. a[1] = a[1] + 1
System.out.println(a[1]); //12

jj = a[1]++; //12
System.out.println(a[1]); //a[1] = 13

mm = a[1];//13
System.out.printf ( "\n%d %d %d\n", ii, jj, mm ) ; //12, 12, 13

for (int val: a) {
     System.out.print(" " +val); //55, 13, 15, 20, 25
}

C ++ පෝස්ට් / පොයින්ටර් විචල්‍යයේ පූර්ව වර්ධක

#include <iostream>
using namespace std;

int main() {

    int x=10;
    int* p = &x;

    std::cout<<"address = "<<p<<"\n"; //prints address of x
    std::cout<<"address = "<<p<<"\n"; //prints (address of x) + sizeof(int)
    std::cout<<"address = "<<&x<<"\n"; //prints address of x

    std::cout<<"address = "<<++&x<<"\n"; //error. reference can't re-assign because it is fixed (immutable)
}

කෙටි කලකින්:

++iහා i++ඔබ උත්සවයකට ඔවුන් නැත්තේ නොවේ නම් එම ක්රියා කරයි. ඔබ වැනි දෙයක් භාවිතා කරන්නේ නම් function(i++)හෝfunction(++i) ඔබට වෙනස දැකිය හැකිය.

function(++i)පළමු වර්ධක i 1 කින් වැඩි කරයි, ඉන්පසු මෙය iනව අගයක් සහිත ශ්‍රිතයට ඇතුළත් කරන්න.

function(i++)1 කින් iවැඩි කිරීමෙන් පසුව ශ්‍රිතයට මුලින්ම ඇතුළත් කරන්න i.

int i=4;
printf("%d\n",pow(++i,2));//it prints 25 and i is 5 now
i=4;
printf("%d",pow(i++,2));//it prints 16 i is 5 now

එකම වෙනස වන්නේ විචල්‍යයේ වැඩිවීම සහ ක්‍රියාකරු ආපසු ලබා දෙන අගය අතර මෙහෙයුම් අනුපිළිවෙලයි.

මෙම කේතය සහ එහි ප්‍රතිදානය වෙනස පැහැදිලි කරයි:

#include<stdio.h>

int main(int argc, char* argv[])
{
  unsigned int i=0, a;
  a = i++;
  printf("i before: %d; value returned by i++: %d, i after: %d\n", i, a, i);
  i=0;
  a = ++i;
  printf("i before: %d; value returned by ++i: %d, i after: %d\n", i, a, i);
}

ප්‍රතිදානය:

i before: 1; value returned by i++: 0, i after: 1
i before: 1; value returned by ++i: 1, i after: 1

එබැවින් මූලික වශයෙන් ++iඅගය වැඩි කිරීමෙන් පසු එය i++ආපසු ලබා දෙන අතර අගය වැඩි කිරීමට පෙර එය ආපසු ලබා දෙන්න. අවසානයේදී, අවස්ථා දෙකේදීම iඑහි වටිනාකම වැඩි වේ.

තවත් උදාහරණයක්:

#include<stdio.h>

int main ()
  int i=0;
  int a = i++*2;
  printf("i=0, i++*2=%d\n", a);
  i=0;
  a = ++i * 2;
  printf("i=0, ++i*2=%d\n", a);
  i=0;
  a = (++i) * 2;
  printf("i=0, (++i)*2=%d\n", a);
  i=0;
  a = (++i) * 2;
  printf("i=0, (++i)*2=%d\n", a);
  return 0;
}

ප්‍රතිදානය:

i=0, i++*2=0
i=0, ++i*2=2
i=0, (++i)*2=2
i=0, (++i)*2=2

බොහෝ විට වෙනසක් නැත

යළි අගය තවත් විචල්ය අනුයුක්ත කර ඇත හෝ මෙහෙයුම් තැනක්ද අයදුම් කරනු ලබන අනෙකුත් මෙහෙයුම් අකාර දී (වැටුප් වර්ධක සිදු වූ විට විට වෙනස්කම් පැහැදිලි i++*2වෙනස් වේ ++i*2, නමුත් (i++)*2සහ (++i)*2ඔවුන් එකිනෙකට හුවමාරු වන බොහෝ අවස්ථාවල දී එම අගය නැවත). සම්භාව්‍ය උදාහරණයක් වන්නේ for loop syntax ය:

for(int i=0; i<10; i++)

සමාන බලපෑමක් ඇත

for(int i=0; i<10; ++i)

මතක තබා ගැනීමට රීතිය

ක්‍රියාකරුවන් දෙදෙනා අතර කිසිදු ව්‍යාකූලත්වයක් ඇති නොකිරීමට මම මෙම නියමය අනුගමනය කළෙමි:

පැවරුමට ++සාපේක්ෂව ක්‍රියාකරුගේ පිහිටීම විචල්‍යයට සාපේක්ෂව මෙහෙයුමේ iඅනුපිළිවෙලට සම්බන්ධ කරන්න++

වෙනත් වචන වලින් කිවහොත්:

• ++ පෙර i මාර්ගයෙන් incrementation සිදු කල යුතුය පෙර පැවරුම;
• ++ පසු i අදහස් incrementation සිදු කල යුතුය පසු පැවරුම:

අභ්‍යන්තර ප්‍රකාශනය බහු ප්‍රකාශයක් ලෙස ඔබට සිතිය හැකිය ;

• නඩුව 1

i++;

ඔබට එය එසේ සිතිය හැකිය,

i;
i = i+1;

• නඩුව 2

++i;

ඔබට එය එසේ සිතිය හැකිය,

i = i+i;
i;

a = i ++ යන්නෙන් අදහස් කරන්නේ වත්මන් i අගය a = ++ යන්නෙන් අදහස් කරන්නේ වැඩි කළ i අගය අඩංගු බවයි

වෙනස තේරුම් ගැනීමට උදාහරණය මෙන්න

int i=10;
printf("%d %d",i++,++i);

ප්‍රතිදානය: 10 12/11 11(තර්ක ඇගයීමේ අනුපිළිවෙල අනුවprintf ශ්‍රිතයට , එය සම්පාදකයින් සහ ගෘහ නිර්මාණ හරහා වෙනස් වේ)

පැහැදිලි කිරීම: i++-> iමුද්‍රණය කර පසුව වර්ධක. (10 මුද්‍රණය කරයි, නමුත් i11 බවට පත්වනු ඇත) ++i-> iඅගය වර්ධක සහ අගය මුද්‍රණය කරයි. (මුද්‍රණ 12, සහ 12 හි වටිනාකම iද)