مسابقه اول سیسوگ (مسابقه اول: درک سخت افزار) انتقادهای زیادی رو در پی داشت تا جایی که حتی خودمم به نتیجه مسابقه شک کردم!! یکی دو روز وقت گذاشتم و به بهینه‌ترین شکل ممکن برنامه را به زبان اسمبلی باز نویسی کردم و در کمال تعجب نه تنها نتیجه تغییر نکرد بلکه اختلاف حتی بیشتر هم شد اگر شما عملی تست کردید و نتیجه غیر از چیزی بود که ما اعلام کردیم خوشحال می‌شویم که نتیجه را با هم بررسی کنیم!!
بگذریم این بار قرار چالش ساده‌تر از قبل داشته باشم و فعلاً کاری به سخت افزار نداشته باشم و یکم مسابقه را نرم افزاری کنیم و باید زبان مورد استفاده زبان C است.
صورت مساله:
تابعی بنویسید که دو عدد (از نوع بدون علامت ۱۶ بیتی) را دریافت کند و بزرگترین عدد را برگرداند!
احتمالاً تا اینجا مقداری خنده دار به نظر می‌رسد چرا که به سادگی یک خط زیر میشود تابع را نوشت:
1 2 3 4 | uint16_t Max(uint16_t A,uint16_t B) { return (A>B) ? A:B; } |
البته قرار نیست مسابقه این چنین ساده باشد و لازم است که شرط‌های دیگری هم به آن اضافه کنیم
- نباید از هیچ گونه ساختار شرطی استفاده شود (حتی شرط‌های درون بدنه حلقه)
- از هیچ تابعی نباید استفاده شود مگر آن که بدنه آن با توجه شرط اول باز نویسی شود.
احتمالاً مقداری کار سخت‌تر شد! ولی همچنان راه حل‌های فراوانی میتوانید در اینترنت برای این مسئله پیدا کنید که چند نمونه از آنها را در ادامه قرار میدهیم.
1 2 3 4 5 | int max(int x, int y) { return x - ((x - y) & ((x - y) >> (sizeof(int) * 8 - 1))); } |
یا
1 2 3 4 5 | // Function to find the largest number int largestNum(int a, int b) { return a * (bool)(a / b) + b * (bool)(b / a); } |
و نمونه‌های زیاد دیگر! پس لازمه پیش شرط‌ها را سخت‌گیرانه‌تر کنیم.
پیش شرط ها
- نباید از هیچ گونه ساختار شرطی استفاده شود ( <,>,==,<=,>=,&&,||,!,!= ) {حتی شرط‌های درون بدنه حلقه}
- نباید از عملیات جمع و منهی استفاده شود (-,+,-=,+=)
- نباید از عملیات ضرب و تقسیم استفاده شود (*,/,/=,*=)
- از هیچ تابعی نباید استفاده شود مگر آن که بدنه آن با توجه شرط اول، دوم و سوم بازنویسی شود.
- استفاده مستقیم و غیر مستقیم از دستورات اسمبلی مجاز نمی‌باشد.
اما جایزه
کسانی که بتوانند تابع را با توجه به پیش شرط‌ها پیاده سازی کنند به قید قرعه آموزش برنامه نویسی c برای میکروکنترلر مطابق سبک ناسا را به عنوان هدیه دریافت خواهد کرد.
که البته بعد از انجام مسابقه و با توجه به استقبال شرکت کنندگان, تهیه کننده آموزش نیز یک نسخه به عنوان جایزه در نظر گرفتند.
ارسال جواب
پاسخ‌های خود را در زیر همین پست کامنت کنید.
دقت کنید شرط اول برنده بودن کار کردن تابع به شکل کامل است و شرط دوم ارائه توضیحات کافی در خصوص کارکرد تابع است.
مهلت پاسخ هم تا اخر روز 29 اسفند ماه 98 هست.
شروع سال جدید و پایان چالش دوم سیسوگ
قبل از هر سخنی لازمه که پابان سال ۱۹۳۸ و شروع سال ۱۳۹۹ به تمام دوستان و همراهان سیسوگ تبریک عرض کنم. امیدوارم که در این سال تمام برنامه هاتون با کمترین خطای ممکن کامپایل بشه (بدون خطا که زندگی معنی نداره) و خواسته هاتون محقق بشه. بگذارید بریم سر مسابقه! بگذارید بگم که واقعا انتظار چنین استقبالی رو نداشتم، مخصوصا حجم پاسخ های صحیح واقعا از چیزی که فکر میکردم بیشتر بود که واقعا برام جای خوشحالی داشت و داره.
همونطور که بیشتر دوستان حدس زدند برای حل این مساله باید دست به دامن گیت های دیجیتال شد و دقیقا مشابه کاری که توی ALU برای مقایسه بین اعداد انجام میشه رو اینجا پیاده سازی کنیم. که در واقع این میشه راه مستقیم و یه راه غیر مستفیم هم وجود داره که میشه پیاده سازی توابع جمع و تفریق با کمک گیت های منطقی و استفاده از آنها مطابق معادلات ریاضی مربوطه.
همونطور که پیداست روش اول روش کوتاه تری است٬ و البته پیاده سازی آن هم ساده تر است پس ما هم به سراغ همین راه حل خواهیم رفت. مقایسه دو عدد با کمک گیت های منطقی واقعا ساده است٬ به جدول زیر دقت کنید
1 2 3 4 5 | A B A=B A<B A>B 0 0 1 0 0 0 1 0 1 0 1 0 0 0 1 1 1 1 0 0 |
جدول بالا مقایسه بین دو بیت است که اگر بخواهیم با گیت آن را پیاده سازی کنیم مداری معادل مدار زیر خواهد داشت
گیت مقایسه بین دو بیت
با توجه به نیاز مساله ما تنها نیاز به مثلا عبارت A>B است داریم و برای پیاده سازی آن تنها به یک گیت not و یک گیت and نیاز است. اما متغییر های ما یک بیتی نیستند بلکه ۱۶ بیتی هستند در ضمن مساله که باید به آن توجه داشت ارزش بیت ها است که اگر هر کدام از آنها بیت با ارزش بیشتر داشت قطعا آن عدد بزرگ تر است. پس لازم است که ورودی از مقایسه در مرحله قبل را نیز داشته باشیم. که به سادگی با عبارت زیر قابل تشخصی خواهد بود
1 | ( A & ~(B) ) ^ ( C & ~(A ^ B) ) |
بر اساس همین عبارت و گسترش آن برای ۱۶ بیت به سادگی میتوان این مساله را حل کرد. تنها نکته ای که میماند انتخاب عدد بزرگتر است٬ عبارت فوق خروجی صفر یا یک خواهد داشت چطور می توانیم صفر یا یک را عدد بزرگتر تبدیل کنیم ؟؟؟؟
جواب ساده است با استفاده از آرایه. ایندکس صفر آرایه را عدد b قرار میدهیم و ایندکس یک آن را عدد a. وقتی خروجی عبارت یک باشد یعنی a بزرگتر است و ماا لازم است ایندکس یک آرایه را برگردانیم و وقتی صفر باشد که یعنی b بزرگتر است ایندکس صفر آرایه برمیگردانیم. به همین سادگی کار تمام است. به کد زیر دقت کنید :
1 2 3 4 5 6 7 8 9 10 | #define zCMP(A,B,C) ((((A)&~(B))^((C)&~((A)^(B))))&1) #define yCMP(A,B,C) zCMP((A>>3)&1,(B>>3)&1,zCMP((A>>2)&1,(B>>2)&1,zCMP((A>>1)&1,(B>>1)&1,zCMP(A&1,B&1,C)))) #define xCMP(A,B,C) yCMP(((A>>4)&0xF),((B>>4)&0xF),yCMP((A&0xF),(B&0xF),(C))) #define jCMP(A,B) xCMP(((A>>8)&0xFF),((B>>8)&0xFF),xCMP((A&0xFF),(B&0xFF),0)) uint16_t zMax(uint16_t A,uint16_t B) { uint16_t Tmp[]={B,A}; return Tmp[jCMP(A,B)]; } |
خب دوازده نفر تا الان پاسخ درست را ارائه کردند که روش و راه حل اونها را میتونید در زیر ببنید
نفر اول آقای محمود نقدی :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 | #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include <stdint.h> uint16_t zMax(uint16_t a, uint16_t b) { uint16_t xn = ~(a ^ b); uint16_t nb = ~b; uint16_t a0 = a & 1; uint16_t nb0 = nb & 1; uint16_t xn0 = xn & 1; uint16_t a1 = a & 2; uint16_t nb1 = nb & 2; uint16_t xn1 = xn & 2; a1>>=1; nb1>>=1; xn1>>=1; uint16_t a2 = a & 4; uint16_t nb2 = nb & 4; uint16_t xn2 = xn & 4; a2>>=2; nb2>>=2; xn2>>=2; uint16_t a3 = a & 8; uint16_t nb3 = nb & 8; uint16_t xn3 = xn & 8; a3>>=3; nb3>>=3; xn3>>=3; uint16_t a4 = a & 16; uint16_t nb4 = nb & 16; uint16_t xn4 = xn & 16; a4>>=4; nb4>>=4; xn4>>=4; uint16_t a5 = a & 32; uint16_t nb5 = nb & 32; uint16_t xn5 = xn & 32; a5>>=5; nb5>>=5; xn5>>=5; uint16_t a6 = a & 64; uint16_t nb6 = nb & 64; uint16_t xn6 = xn & 64; a6>>=6; nb6>>=6; xn6>>=6; uint16_t a7 = a & 128; uint16_t nb7 = nb & 128; uint16_t xn7 = xn & 128; a7>>=7; nb7>>=7; xn7>>=7; uint16_t a8 = a & 256; uint16_t nb8 = nb & 256; uint16_t xn8 = xn & 256; a8>>=8; nb8>>=8; xn8>>=8; uint16_t a9 = a & 512; uint16_t nb9 = nb & 512; uint16_t xn9 = xn & 512; a9>>=9; nb9>>=9; xn9>>=9; uint16_t a10 = a & 1024; uint16_t nb10 = nb & 1024; uint16_t xn10 = xn & 1024; a10>>=10; nb10>>=10; xn10>>=10; uint16_t a11 = a & 2048; uint16_t nb11 = nb & 2048; uint16_t xn11 = xn & 2048; a11>>=11; nb11>>=11; xn11>>=11; uint16_t a12 = a & 4096; uint16_t nb12 = nb & 4096; uint16_t xn12 = xn & 4096; a12>>=12; nb12>>=12; xn12>>=12; uint16_t a13 = a & 8192; uint16_t nb13 = nb & 8192; uint16_t xn13 = xn & 8192; a13>>=13; nb13>>=13; xn13>>=13; uint16_t a14 = a & 16384; uint16_t nb14 = nb & 16384; uint16_t xn14 = xn & 16384; a14>>=14; nb14>>=14; xn14>>=14; uint16_t a15 = a & 32768; uint16_t nb15 = nb & 32768; uint16_t xn15 = xn & 32768; a15>>=15; nb15>>=15; xn15>>=15; uint16_t and0 = a0 & nb0 & xn1 & xn2 & xn3 & xn4 & xn5 & xn6 & xn7 & xn8 & xn9 & xn10 & xn11 & xn12 & xn13 & xn14 &xn15; uint16_t and1 = a1 & nb1 & xn2 & xn3 & xn4 & xn5 & xn6 & xn7 & xn8 & xn9 & xn10 & xn11 & xn12 & xn13 & xn14 &xn15; uint16_t and2 = a2 & nb2 & xn3 & xn4 & xn5 & xn6 & xn7 & xn8 & xn9 & xn10 & xn11 & xn12 & xn13 & xn14 &xn15; uint16_t and3 = a3 & nb3 & xn4 & xn5 & xn6 & xn7 & xn8 & xn9 & xn10 & xn11 & xn12 & xn13 & xn14 &xn15; uint16_t and4 = a4 & nb4 & xn5 & xn6 & xn7 & xn8 & xn9 & xn10 & xn11 & xn12 & xn13 & xn14 &xn15; uint16_t and5 = a5 & nb5 & xn6 & xn7 & xn8 & xn9 & xn10 & xn11 & xn12 & xn13 & xn14 &xn15; uint16_t and6 = a6 & nb6 & xn7 & xn8 & xn9 & xn10 & xn11 & xn12 & xn13 & xn14 &xn15; uint16_t and7 = a7 & nb7 & xn8 & xn9 & xn10 & xn11 & xn12 & xn13 & xn14 &xn15; uint16_t and8 = a8 & nb8 & xn9 & xn10 & xn11 & xn12 & xn13 & xn14 &xn15; uint16_t and9 = a9 & nb9 & xn10 & xn11 & xn12 & xn13 & xn14 &xn15; uint16_t and10 = a10 & nb10 & xn11 & xn12 & xn13 & xn14 &xn15; uint16_t and11 = a11 & nb11 & xn12 & xn13 & xn14 &xn15; uint16_t and12 = a12 & nb12 & xn13 & xn14 &xn15; uint16_t and13 = a13 & nb13 & xn14 &xn15; uint16_t and14 = a14 & nb14 & xn15; uint16_t and15 = a15 & nb15; uint16_t a_is_largest = and0 | and1 | and2 | and3 | and4 | and5 | and6 | and7 | and8 | and9 | and10 | and11 | and12 | and13 | and14 | and15; uint16_t base = 0; base |= a_is_largest; base |= a_is_largest<<1; base |= a_is_largest<<2; base |= a_is_largest<<3; base |= a_is_largest<<4; base |= a_is_largest<<5; base |= a_is_largest<<6; base |= a_is_largest<<7; base |= a_is_largest<<8; base |= a_is_largest<<9; base |= a_is_largest<<10; base |= a_is_largest<<11; base |= a_is_largest<<12; base |= a_is_largest<<13; base |= a_is_largest<<14; base |= a_is_largest<<15; return (a & base) | (b & ~base); } |
نفر دوم آقای محمدجواد واعظ :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 | #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include <stdint.h> bool g(bool a, bool b) //g(a,b)= 1 if a is greater than b (a and b are two bits) {return a&(~b);} bool e(bool a, bool b) //e(a,b)= 1 if a equals b (a and b are two bits) {return(~(a^b) & 0x0001);} uint16_t zMax(int x, int y) { //seperating the bits of x and y bool x0 = x & 1, y0 = y & 1; bool x1 = x & 2, y1 = y & 2; bool x2 = x & 4, y2 = y & 4; bool x3 = x & 8, y3 = y & 8; bool x4 = x & 16, y4 = y & 16; bool x5 = x & 32, y5 = y & 32; bool x6 = x & 64, y6 = y & 64; bool x7 = x & 128, y7 = y & 128; bool x8 = x & 256, y8 = y & 256; bool x9 = x & 512, y9 = y & 512; bool x10 = x & 1024, y10 = y & 1024; bool x11 = x & 2048, y11 = y & 2048; bool x12 = x & 4096, y12 = y & 4096; bool x13 = x & 8192, y13 = y & 8192; bool x14 = x & 16384, y14 = y & 16384; bool x15 = x & 32768, y15 = y & 32768; //If x>y, either x0>y0, or they’re equal but x1>y1 and so on bool b1 = g(x15,y15); bool b2 = e(x15,y15)&g(x14,y14); bool b3 = e(x15,y15)&e(x14,y14)&g(x13,y13); bool b4 = e(x15,y15)&e(x14,y14)&e(x13,y13)&g(x12,y12); bool b5 = e(x15,y15)&e(x14,y14)&e(x13,y13)&e(x12,y12)&g(x11,y11); bool b6 = e(x15,y15)&e(x14,y14)&e(x13,y13)&e(x12,y12)&e(x11,y11)&g(x10,y10); bool b7 = e(x15,y15)&e(x14,y14)&e(x13,y13)&e(x12,y12)&e(x11,y11)&e(x10,y10)&g(x9,y9); bool b8 = e(x15,y15)&e(x14,y14)&e(x13,y13)&e(x12,y12)&e(x11,y11)&e(x10,y10)&e(x9,y9)&g(x8,y8); bool b9 = e(x15,y15)&e(x14,y14)&e(x13,y13)&e(x12,y12)&e(x11,y11)&e(x10,y10)&e(x9,y9)&e(x8,y8)&g(x7,y7); bool b10 = e(x15,y15)&e(x14,y14)&e(x13,y13)&e(x12,y12)&e(x11,y11)&e(x10,y10)&e(x9,y9)&e(x8,y8)&e(x7,y7)&g(x6,y6); bool b11 = e(x15,y15)&e(x14,y14)&e(x13,y13)&e(x12,y12)&e(x11,y11)&e(x10,y10)&e(x9,y9)&e(x8,y8)&e(x7,y7)&e(x6,y6)&g(x5,y5); bool b12 = e(x15,y15)&e(x14,y14)&e(x13,y13)&e(x12,y12)&e(x11,y11)&e(x10,y10)&e(x9,y9)&e(x8,y8)&e(x7,y7)&e(x6,y6)&e(x5,y5)&g(x4,y4); bool b13 = e(x15,y15)&e(x14,y14)&e(x13,y13)&e(x12,y12)&e(x11,y11)&e(x10,y10)&e(x9,y9)&e(x8,y8)&e(x7,y7)&e(x6,y6)&e(x5,y5)&e(x4,y4)&g(x3,y3); bool b14 = e(x15,y15)&e(x14,y14)&e(x13,y13)&e(x12,y12)&e(x11,y11)&e(x10,y10)&e(x9,y9)&e(x8,y8)&e(x7,y7)&e(x6,y6)&e(x5,y5)&e(x4,y4)&e(x3,y3)&g(x2,y2); bool b15 = e(x15,y15)&e(x14,y14)&e(x13,y13)&e(x12,y12)&e(x11,y11)&e(x10,y10)&e(x9,y9)&e(x8,y8)&e(x7,y7)&e(x6,y6)&e(x5,y5)&e(x4,y4)&e(x3,y3)&e(x2,y2)&g(x1,y1); bool b16 = e(x15,y15)&e(x14,y14)&e(x13,y13)&e(x12,y12)&e(x11,y11)&e(x10,y10)&e(x9,y9)&e(x8,y8)&e(x7,y7)&e(x6,y6)&e(x5,y5)&e(x4,y4)&e(x3,y3)&e(x2,y2)&e(x1,y1)&g(x0,y0); bool x_is_g = b1 | b2 | b3 | b4 | b5 | b6 | b7 | b8 | b9 | b10 | b11 | b12 | b13 | b14 | b15 | b16; int x_is_greater = x_is_g | (x_is_g<<1) | (x_is_g<<2) | (x_is_g<<3) | (x_is_g<<4) | (x_is_g<<5) | (x_is_g<<6) | (x_is_g<<7) | (x_is_g<<8) | (x_is_g<<9) | (x_is_g<<10) | (x_is_g<<11) | (x_is_g<<12)| (x_is_g<<13) | (x_is_g<<14) | (x_is_g<<15); //this variable will be either 0 or 0xFFFF return ((x_is_greater & x) | ((~x_is_greater)&y)); //if x_is_greater is 0, then y will be returned, otherwise it's 0xFFFF and x will be returned } uint16_t Max(uint16_t A,uint16_t B) { return (A>B) ? A:B; } |
نفر سوم آقای مهدی خلیلی فر :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 | #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include <stdint.h> void fun(uint16_t *a,uint16_t *b,uint16_t *aFlag,uint16_t *bFlag,uint16_t *temp) { uint16_t c = *temp & (*a ^ *b) & *a; uint16_t d = *temp & (*a ^ *b) & *b; *aFlag |= (*aFlag>>1) | ( c & (~(*bFlag >> 1))); *bFlag |= (*bFlag>>1) | ( d & (~(*aFlag >> 1))); *temp = *temp >> 1; } uint16_t zMax(uint16_t a, uint16_t b) { uint16_t aFlag = 0, bFlag = 0, temp = 0x8000; fun(&a,&b,&aFlag,&bFlag,&temp); fun(&a,&b,&aFlag,&bFlag,&temp); fun(&a,&b,&aFlag,&bFlag,&temp); fun(&a,&b,&aFlag,&bFlag,&temp); fun(&a,&b,&aFlag,&bFlag,&temp); fun(&a,&b,&aFlag,&bFlag,&temp); fun(&a,&b,&aFlag,&bFlag,&temp); fun(&a,&b,&aFlag,&bFlag,&temp); fun(&a,&b,&aFlag,&bFlag,&temp); fun(&a,&b,&aFlag,&bFlag,&temp); fun(&a,&b,&aFlag,&bFlag,&temp); fun(&a,&b,&aFlag,&bFlag,&temp); fun(&a,&b,&aFlag,&bFlag,&temp); fun(&a,&b,&aFlag,&bFlag,&temp); fun(&a,&b,&aFlag,&bFlag,&temp); fun(&a,&b,&aFlag,&bFlag,&temp); return (a & aFlag) | (b & ~aFlag); } |
نفر چهارم آقای شهرام نوربخش راد:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 | #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include <stdint.h> //—————- WORD_BYTES 16-bit typedef union _WORD_BYTES { uint16_t word; uint8_t bytes[2]; struct { uint8_t LB; uint8_t HB; } byte; struct { unsigned char bit0:1; unsigned char bit1:1; unsigned char bit2:1; unsigned char bit3:1; unsigned char bit4:1; unsigned char bit5:1; unsigned char bit6:1; unsigned char bit7:1; unsigned char bit8:1; unsigned char bit9:1; unsigned char bit10:1; unsigned char bit11:1; unsigned char bit12:1; unsigned char bit13:1; unsigned char bit14:1; unsigned char bit15:1; } bits; } WORD_BYTES; unsigned int zMax(unsigned int inA, unsigned int inB) { unsigned char AcaB, AcoB; unsigned int Bnt; WORD_BYTES ABnt, AxnB; unsigned int AgB, Rslt; //——————– Bnt = ~inB; ABnt.word = inA &Bnt; AxnB.word = ~(inA ^inB); //——————– AcoB = ABnt.bits.bit15; AcaB = AxnB.bits.bit15; AcoB |= (ABnt.bits.bit14 &AcaB); AcaB &= AxnB.bits.bit14; AcoB |= (ABnt.bits.bit13 &AcaB); AcaB &= AxnB.bits.bit13; AcoB |= (ABnt.bits.bit12 &AcaB); AcaB &= AxnB.bits.bit12; AcoB |= (ABnt.bits.bit11 &AcaB); AcaB &= AxnB.bits.bit11; AcoB |= (ABnt.bits.bit10 &AcaB); AcaB &= AxnB.bits.bit10; AcoB |= (ABnt.bits.bit9 &AcaB); AcaB &= AxnB.bits.bit9; AcoB |= (ABnt.bits.bit8 &AcaB); AcaB &= AxnB.bits.bit8; AcoB |= (ABnt.bits.bit7 &AcaB); AcaB &= AxnB.bits.bit7; AcoB |= (ABnt.bits.bit6 &AcaB); AcaB &= AxnB.bits.bit6; AcoB |= (ABnt.bits.bit5 &AcaB); AcaB &= AxnB.bits.bit5; AcoB |= (ABnt.bits.bit4 &AcaB); AcaB &= AxnB.bits.bit4; AcoB |= (ABnt.bits.bit3 &AcaB); AcaB &= AxnB.bits.bit3; AcoB |= (ABnt.bits.bit2 &AcaB); AcaB &= AxnB.bits.bit2; AcoB |= (ABnt.bits.bit1 &AcaB); AcaB &= AxnB.bits.bit1; AcoB |= (ABnt.bits.bit0 &AcaB); //——————– AgB = 0x0000; for(int i=0; i<16; i++) AgB |= (AcoB <<i); Rslt = inA &AgB; AgB = ~AgB; Rslt |= (inB &AgB); //——————– return Rslt; } //Compar |
نفر پنجم آقای کامین جلیلی:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 | #include <stdio.h> #include <stdlib.h> #include <stdint.h> uint16_t A, B; union { uint16_t A_Data; struct { uint16_t A0 : 1; uint16_t A1 : 1; uint16_t A2 : 1; uint16_t A3 : 1; uint16_t A4 : 1; uint16_t A5 : 1; uint16_t A6 : 1; uint16_t A7 : 1; uint16_t A8 : 1; uint16_t A9 : 1; uint16_t A10 : 1; uint16_t A11 : 1; uint16_t A12 : 1; uint16_t A13 : 1; uint16_t A14 : 1; uint16_t A15 : 1; }bits; }A_Read_bit; union { uint16_t B_Data; struct { uint16_t B0 : 1; uint16_t B1 : 1; uint16_t B2 : 1; uint16_t B3 : 1; uint16_t B4 : 1; uint16_t B5 : 1; uint16_t B6 : 1; uint16_t B7 : 1; uint16_t B8 : 1; uint16_t B9 : 1; uint16_t B10 : 1; uint16_t B11 : 1; uint16_t B12 : 1; uint16_t B13 : 1; uint16_t B14 : 1; uint16_t B15 : 1; }bits; }B_Read_bit; struct { uint16_t X0 : 1; uint16_t X1 : 1; uint16_t X2 : 1; uint16_t X3 : 1; uint16_t X4 : 1; uint16_t X5 : 1; uint16_t X6 : 1; uint16_t X7 : 1; uint16_t X8 : 1; uint16_t X9 : 1; uint16_t X10 : 1; uint16_t X11 : 1; uint16_t X12 : 1; uint16_t X13 : 1; uint16_t X14 : 1; uint16_t X15 : 1; }X_Read_bit; struct { uint16_t A_Bigger_B : 1; uint16_t A_Equal_B : 1; uint16_t A_Smaller_B : 1; }Compare; int main() { printf("Please Enter A: "); scanf("%d" , &A); printf("Please Enter B: "); scanf("%d" , &B); A_Read_bit.A_Data = A; B_Read_bit.B_Data = B; X_Read_bit.X0 = (A_Read_bit.bits.A0 & B_Read_bit.bits.B0) | (~A_Read_bit.bits.A0 & ~B_Read_bit.bits.B0); X_Read_bit.X1 = (A_Read_bit.bits.A1 & B_Read_bit.bits.B1) | (~A_Read_bit.bits.A1 & ~B_Read_bit.bits.B1); X_Read_bit.X2 = (A_Read_bit.bits.A2 & B_Read_bit.bits.B2) | (~A_Read_bit.bits.A2 & ~B_Read_bit.bits.B2); X_Read_bit.X3 = (A_Read_bit.bits.A3 & B_Read_bit.bits.B3) | (~A_Read_bit.bits.A3 & ~B_Read_bit.bits.B3); X_Read_bit.X4 = (A_Read_bit.bits.A4 & B_Read_bit.bits.B4) | (~A_Read_bit.bits.A4 & ~B_Read_bit.bits.B4); X_Read_bit.X5 = (A_Read_bit.bits.A5 & B_Read_bit.bits.B5) | (~A_Read_bit.bits.A5 & ~B_Read_bit.bits.B5); X_Read_bit.X6 = (A_Read_bit.bits.A6 & B_Read_bit.bits.B6) | (~A_Read_bit.bits.A6 & ~B_Read_bit.bits.B6); X_Read_bit.X7 = (A_Read_bit.bits.A7 & B_Read_bit.bits.B7) | (~A_Read_bit.bits.A7 & ~B_Read_bit.bits.B7); X_Read_bit.X8 = (A_Read_bit.bits.A8 & B_Read_bit.bits.B8) | (~A_Read_bit.bits.A8 & ~B_Read_bit.bits.B8); X_Read_bit.X9 = (A_Read_bit.bits.A9 & B_Read_bit.bits.B9) | (~A_Read_bit.bits.A9 & ~B_Read_bit.bits.B9); X_Read_bit.X10 = (A_Read_bit.bits.A10 & B_Read_bit.bits.B10) | (~A_Read_bit.bits.A10 & ~B_Read_bit.bits.B10); X_Read_bit.X11 = (A_Read_bit.bits.A11 & B_Read_bit.bits.B11) | (~A_Read_bit.bits.A11 & ~B_Read_bit.bits.B11); X_Read_bit.X12 = (A_Read_bit.bits.A12 & B_Read_bit.bits.B12) | (~A_Read_bit.bits.A12 & ~B_Read_bit.bits.B12); X_Read_bit.X13 = (A_Read_bit.bits.A13 & B_Read_bit.bits.B13) | (~A_Read_bit.bits.A13 & ~B_Read_bit.bits.B13); X_Read_bit.X14 = (A_Read_bit.bits.A14 & B_Read_bit.bits.B14) | (~A_Read_bit.bits.A14 & ~B_Read_bit.bits.B14); X_Read_bit.X15 = (A_Read_bit.bits.A15 & B_Read_bit.bits.B15) | (~A_Read_bit.bits.A15 & ~B_Read_bit.bits.B15); Compare.A_Bigger_B = (A_Read_bit.bits.A15 & ~B_Read_bit.bits.B15) | (A_Read_bit.bits.A14 & ~B_Read_bit.bits.B14 & X_Read_bit.X15) | (A_Read_bit.bits.A13 & ~B_Read_bit.bits.B13 & X_Read_bit.X15 & X_Read_bit.X14) | (A_Read_bit.bits.A12 & ~B_Read_bit.bits.B12 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13) | (A_Read_bit.bits.A11 & ~B_Read_bit.bits.B11 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13 & X_Read_bit.X12) | (A_Read_bit.bits.A10 & ~B_Read_bit.bits.B10 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13 & X_Read_bit.X12 & X_Read_bit.X11) | (A_Read_bit.bits.A9 & ~B_Read_bit.bits.B9 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13 & X_Read_bit.X12 & X_Read_bit.X11 & X_Read_bit.X10) | (A_Read_bit.bits.A8 & ~B_Read_bit.bits.B8 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13 & X_Read_bit.X12 & X_Read_bit.X11 & X_Read_bit.X10 & X_Read_bit.X9) | (A_Read_bit.bits.A7 & ~B_Read_bit.bits.B7 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13 & X_Read_bit.X12 & X_Read_bit.X11 & X_Read_bit.X10 & X_Read_bit.X9 & X_Read_bit.X8) | (A_Read_bit.bits.A6 & ~B_Read_bit.bits.B6 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13 & X_Read_bit.X12 & X_Read_bit.X11 & X_Read_bit.X10 & X_Read_bit.X9 & X_Read_bit.X8 & X_Read_bit.X7) | (A_Read_bit.bits.A5 & ~B_Read_bit.bits.B5 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13 & X_Read_bit.X12 & X_Read_bit.X11 & X_Read_bit.X10 & X_Read_bit.X9 & X_Read_bit.X8 & X_Read_bit.X7 & X_Read_bit.X6) | (A_Read_bit.bits.A4 & ~B_Read_bit.bits.B4 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13 & X_Read_bit.X12 & X_Read_bit.X11 & X_Read_bit.X10 & X_Read_bit.X9 & X_Read_bit.X8 & X_Read_bit.X7 & X_Read_bit.X6 & X_Read_bit.X5) | (A_Read_bit.bits.A3 & ~B_Read_bit.bits.B3 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13 & X_Read_bit.X12 & X_Read_bit.X11 & X_Read_bit.X10 & X_Read_bit.X9 & X_Read_bit.X8 & X_Read_bit.X7 & X_Read_bit.X6 & X_Read_bit.X5 & X_Read_bit.X4) | (A_Read_bit.bits.A2 & ~B_Read_bit.bits.B2 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13 & X_Read_bit.X12 & X_Read_bit.X11 & X_Read_bit.X10 & X_Read_bit.X9 & X_Read_bit.X8 & X_Read_bit.X7 & X_Read_bit.X6 & X_Read_bit.X5 & X_Read_bit.X4 & X_Read_bit.X3) | (A_Read_bit.bits.A1 & ~B_Read_bit.bits.B1 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13 & X_Read_bit.X12 & X_Read_bit.X11 & X_Read_bit.X10 & X_Read_bit.X9 & X_Read_bit.X8 & X_Read_bit.X7 & X_Read_bit.X6 & X_Read_bit.X5 & X_Read_bit.X4 & X_Read_bit.X3 & X_Read_bit.X2) | (A_Read_bit.bits.A0 & ~B_Read_bit.bits.B0 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13 & X_Read_bit.X12 & X_Read_bit.X11 & X_Read_bit.X10 & X_Read_bit.X9 & X_Read_bit.X8 & X_Read_bit.X7 & X_Read_bit.X6 & X_Read_bit.X5 & X_Read_bit.X4 & X_Read_bit.X3 & X_Read_bit.X2 & X_Read_bit.X1); Compare.A_Smaller_B = (~A_Read_bit.bits.A15 & B_Read_bit.bits.B15) | (~A_Read_bit.bits.A14 & B_Read_bit.bits.B14 & X_Read_bit.X15) | (~A_Read_bit.bits.A13 & B_Read_bit.bits.B13 & X_Read_bit.X15 & X_Read_bit.X14) | (~A_Read_bit.bits.A12 & B_Read_bit.bits.B12 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13) | (~A_Read_bit.bits.A11 & B_Read_bit.bits.B11 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13 & X_Read_bit.X12) | (~A_Read_bit.bits.A10 & B_Read_bit.bits.B10 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13 & X_Read_bit.X12 & X_Read_bit.X11) | (~A_Read_bit.bits.A9 & B_Read_bit.bits.B9 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13 & X_Read_bit.X12 & X_Read_bit.X11 & X_Read_bit.X10) | (A_Read_bit.bits.A8 & B_Read_bit.bits.B8 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13 & X_Read_bit.X12 & X_Read_bit.X11 & X_Read_bit.X10 & X_Read_bit.X9) | (~A_Read_bit.bits.A7 & B_Read_bit.bits.B7 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13 & X_Read_bit.X12 & X_Read_bit.X11 & X_Read_bit.X10 & X_Read_bit.X9 & X_Read_bit.X8) | (~A_Read_bit.bits.A6 & B_Read_bit.bits.B6 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13 & X_Read_bit.X12 & X_Read_bit.X11 & X_Read_bit.X10 & X_Read_bit.X9 & X_Read_bit.X8 & X_Read_bit.X7) | (~A_Read_bit.bits.A5 & B_Read_bit.bits.B5 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13 & X_Read_bit.X12 & X_Read_bit.X11 & X_Read_bit.X10 & X_Read_bit.X9 & X_Read_bit.X8 & X_Read_bit.X7 & X_Read_bit.X6) | (~A_Read_bit.bits.A4 & B_Read_bit.bits.B4 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13 & X_Read_bit.X12 & X_Read_bit.X11 & X_Read_bit.X10 & X_Read_bit.X9 & X_Read_bit.X8 & X_Read_bit.X7 & X_Read_bit.X6 & X_Read_bit.X5) | (~A_Read_bit.bits.A3 & B_Read_bit.bits.B3 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13 & X_Read_bit.X12 & X_Read_bit.X11 & X_Read_bit.X10 & X_Read_bit.X9 & X_Read_bit.X8 & X_Read_bit.X7 & X_Read_bit.X6 & X_Read_bit.X5 & X_Read_bit.X4) | (~A_Read_bit.bits.A2 & B_Read_bit.bits.B2 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13 & X_Read_bit.X12 & X_Read_bit.X11 & X_Read_bit.X10 & X_Read_bit.X9 & X_Read_bit.X8 & X_Read_bit.X7 & X_Read_bit.X6 & X_Read_bit.X5 & X_Read_bit.X4 & X_Read_bit.X3) | (~A_Read_bit.bits.A1 & B_Read_bit.bits.B1 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13 & X_Read_bit.X12 & X_Read_bit.X11 & X_Read_bit.X10 & X_Read_bit.X9 & X_Read_bit.X8 & X_Read_bit.X7 & X_Read_bit.X6 & X_Read_bit.X5 & X_Read_bit.X4 & X_Read_bit.X3 & X_Read_bit.X2) | (~A_Read_bit.bits.A0 & B_Read_bit.bits.B0 & X_Read_bit.X15 & X_Read_bit.X14 & X_Read_bit.X13 & X_Read_bit.X12 & X_Read_bit.X11 & X_Read_bit.X10 & X_Read_bit.X9 & X_Read_bit.X8 & X_Read_bit.X7 & X_Read_bit.X6 & X_Read_bit.X5 & X_Read_bit.X4 & X_Read_bit.X3 & X_Read_bit.X2 & X_Read_bit.X1); Compare.A_Equal_B = (X_Read_bit.X0 & X_Read_bit.X1 & X_Read_bit.X2 & X_Read_bit.X3 & X_Read_bit.X4 & X_Read_bit.X5 & X_Read_bit.X6 & X_Read_bit.X7 & X_Read_bit.X8 & X_Read_bit.X9 & X_Read_bit.X10 & X_Read_bit.X11 & X_Read_bit.X12 & X_Read_bit.X13 & X_Read_bit.X14 & X_Read_bit.X15); printf("A_Bigger_B : %d \n A_Smaller_B: %d \n A_Equal_B : %d", Compare.A_Bigger_B, Compare.A_Smaller_B, Compare.A_Equal_B); } |
نفر ششم آقای سعید گرجی:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 | uint16_t zMax(uint16_t a, uint16_t b) { /* the idea is to make the cpu simulate something like a 16-bit digital comparator! */ uint16_t xor=0; uint16_t greater_a_indicator=0; uint16_t cyclic_or=0; uint16_t a_validator_mask=0; /* in fact, we need XNOR, but XOR simplifies the code */ xor = a ^ b; greater_a_indicator = a & ~b; /* append 1 instead of 0 in shift operations */ greater_a_indicator &= ~(xor >> 1) & ~(xor >> 2) & ~(xor >> 3) & ~(xor >> 4) & ~(xor >> 5) & ~(xor >> 6) & ~(xor >> 7) & ~(xor >> 8) & ~(xor >> 9) & ~(xor >> 10) & ~(xor >> 11) & ~(xor >> 12) & ~(xor >> 13) & ~(xor >> 14) & ~(xor >> 15); /* if greater_a_indicator is something other than zero, the “a” is bigger, otherwise “b” would be the return value (either “a” equals to “b” or “a” is less than “b”) */ /* OR all the bits of greater_a_indicator */ cyclic_or = ((greater_a_indicator >> 0) & (uint16_t)0x0001) | ((greater_a_indicator >> 1) & (uint16_t)0x0001) | ((greater_a_indicator >> 2) & (uint16_t)0x0001) | ((greater_a_indicator >> 3) & (uint16_t)0x0001) | ((greater_a_indicator >> 4) & (uint16_t)0x0001) | ((greater_a_indicator >> 5) & (uint16_t)0x0001) | ((greater_a_indicator >> 6) & (uint16_t)0x0001) | ((greater_a_indicator >> 7) & (uint16_t)0x0001) | ((greater_a_indicator >> 8) & (uint16_t)0x0001) | ((greater_a_indicator >> 9) & (uint16_t)0x0001) | ((greater_a_indicator >> 10) & (uint16_t)0x0001) | ((greater_a_indicator >> 11) & (uint16_t)0x0001) | ((greater_a_indicator >> 12) & (uint16_t)0x0001) | ((greater_a_indicator >> 13) & (uint16_t)0x0001) | ((greater_a_indicator >> 14) & (uint16_t)0x0001) | ((greater_a_indicator >> 15) & (uint16_t)0x0001); cyclic_or &= (uint16_t)0x0001; /* reproduce the least significant bit of cyclic_or to fill up the entire a_validator_mask bits */ a_validator_mask = (cyclic_or << 0) | (cyclic_or << 1) | (cyclic_or << 2) | (cyclic_or << 3) | (cyclic_or << 4) | (cyclic_or << 5) | (cyclic_or << 6) | (cyclic_or << 7) | (cyclic_or << 8) | (cyclic_or << 9) | (cyclic_or << 10) | (cyclic_or << 11) | (cyclic_or << 12) | (cyclic_or << 13) | (cyclic_or << 14) | (cyclic_or << 15); return (a & a_validator_mask) | (b & ~a_validator_mask); } |
نفر هفتم آقای رسول بیرانوند:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 | #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include <stdint.h> unsigned int zMax( unsigned int x ,unsigned int y ){ unsigned int a=0,b=0; unsigned int Arr[2]={0x0,0xffff}; unsigned int flag=0; unsigned int large =0; a = x & (1<<15); a >>= 15; b = y & (1<<15); b >>= 15; flag = a ^ b; flag = (~flag) & 1; x &= Arr[a | flag]; y &= Arr[b | flag]; a = x & (1<<14); a >>= 14; b = y & (1<<14); b >>= 14; flag = a ^ b; flag = (~flag) & 1; x &= Arr[a | flag]; y &= Arr[b | flag]; a = x & (1<<13); a >>= 13; b = y & (1<<13); b >>= 13; flag = a ^ b; flag = (~flag) & 1; x &= Arr[a | flag]; y &= Arr[b | flag]; a = x & (1<<12); a >>= 12; b = y & (1<<12); b >>= 12; flag = a ^ b; flag = (~flag) & 1; x &= Arr[a | flag]; y &= Arr[b | flag]; a = x & (1<<11); a >>= 11; b = y & (1<<11); b >>= 11; flag = a ^ b; flag = (~flag) & 1; x &= Arr[a | flag]; y &= Arr[b | flag]; a = x & (1<<10); a >>= 10; b = y & (1<<10); b >>= 10; flag = a ^ b; flag = (~flag) & 1; x &= Arr[a | flag]; y &= Arr[b | flag]; a = x & (1<<9); a >>= 9; b = y & (1<<9); b >>= 9; flag = a ^ b; flag = (~flag) & 1; x &= Arr[a | flag]; y &= Arr[b | flag]; a = x & (1<<8); a >>= 8; b = y & (1<<8); b >>= 8; flag = a ^ b; flag = (~flag) & 1; x &= Arr[a | flag]; y &= Arr[b | flag]; a = x & (1<<7); a >>= 7; b = y & (1<<7); b >>= 7; flag = a ^ b; flag = (~flag) & 1; x &= Arr[a | flag]; y &= Arr[b | flag]; a = x & (1<<6); a >>= 6; b = y & (1<<6); b >>= 6; flag = a ^ b; flag = (~flag) & 1; x &= Arr[a | flag]; y &= Arr[b | flag]; a = x & (1<<5); a >>= 5; b = y & (1<<5); b >>= 5; flag = a ^ b; flag = (~flag) & 1; x &= Arr[a | flag]; y &= Arr[b | flag]; a = x & (1<<4); a >>= 4; b = y & (1<<4); b >>= 4; flag = a ^ b; flag = (~flag) & 1; x &= Arr[a | flag]; y &= Arr[b | flag]; a = x & (1<<3); a >>= 3; b = y & (1<<3); b >>= 3; flag = a ^ b; flag = (~flag) & 1; x &= Arr[a | flag]; y &= Arr[b | flag]; a = x & (1<<2); a >>= 2; b = y & (1<<2); b >>= 2; flag = a ^ b; flag = (~flag) & 1; x &= Arr[a | flag]; y &= Arr[b | flag]; a = x & (1<<1); a >>= 1; b = y & (1<<1); b >>= 1; flag = a ^ b; flag = (~flag) & 1; x &= Arr[a | flag]; y &= Arr[b | flag]; a = x & (1<<0); a >>= 0; b = y & (1<<0); b >>= 0; flag = a ^ b; flag = (~flag) & 1; x &= Arr[a | flag]; y &= Arr[b | flag]; large = x | y; return large; } |
نفر هشتم آقای مهدی راهی:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 | #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include <stdint.h> uint16_t find_bigger_value(const uint16_t a, const uint16_t b); // uint32_t multiply(const uint16_t a, const uint16_t b); uint32_t assist_Multiply(const uint16_t a, const uint16_t* const b); // uint32_t addition(const uint32_t x, const uint32_t y); uint32_t assist_Addition(uint32_t* const a, uint32_t* const b, uint32_t* const positiveCarry); // uint32_t subtraction(const uint32_t x, const uint32_t y); uint32_t assist_Subtraction(uint32_t* const a, uint32_t* const b, uint32_t* const negativeCarry); uint16_t zMax( uint16_t a ,uint16_t b ) { return find_bigger_value(a,b); } uint16_t Max(uint16_t A,uint16_t B) { return (A>B) ? A:B; } int main(void) { puts("!!!Hello World!!!\r\n"); /* prints !!!Hello World!!! */ uint16_t breakc = 0; for(int A=0;A<0xFFFF;A++) { for(int B=0;B<0xFFFF;B++) { if(zMax(A,B)!=Max(A,B)) { printf("A=%i,B=%i\tMax=%i\r\n",A,B,zMax(A,B)); if(breakc++>=4) { printf("\r\n END."); return EXIT_SUCCESS; } } } } printf("\r\n END."); return EXIT_SUCCESS; } uint16_t find_bigger_value(const uint16_t a, const uint16_t b) { //test with visual studio is ok. //if two value is equal then return input else return bigger value. uint32_t A = 0; uint32_t B = 0; uint32_t bigger = 0; //1) if between two 16 bit value (lowerValue - biggerValue) and save in 32 bit then sure last bit = 1, // (Note: name for lower last bit = lowerSymbol, and name for bigger last bit = biggerSymbol) // //2) So read the last bit value and if equal to 1, this is lower and the other is bigger. // //3) now (lowerSymbol=1) and (biggerSymbol=0), if inverted this two value then (lowerSymbol=0) and (biggerSymbol=1). // //4) multiply lowerSymbol to corresponding input (returned 0), and multiply biggerSymbol to corresponding input(returned corresponding input). // //5) in end with 'or' multiply result returned 'corresponding input' that this 'corresponding input' equal with bigger input. //1) subtraction between two 16 bit value A = subtraction(a, b); //A = a - b B = subtraction(b, a); //B = b - a //2) read last bit(get lower and bigger symbol). A = ((A & 0b10000000000000000000000000000000) >> 31); //0=bigger, 1=lower B = ((B & 0b10000000000000000000000000000000) >> 31); //0=bigger, 1=lower //3) inverted lower and bigger symbol. A = addition(A, 1); A = (A & 0b00000000000000000000000000000001); // B = addition(B, 1); B = (B & 0b00000000000000000000000000000001); //4) mulyiply lower and bigger symbol with 'corresponding input'. A = (multiply(A, a)); B = (multiply(B, b)); //5) 'or' multiply result. bigger = (A | B); return bigger; } uint32_t multiply(const uint16_t a, const uint16_t b) { //test with visual studio is ok. //Multiplication operation like the third elementary school: // 1) bit-by-bit separation of input value(input value is unsigned 16 bit). // 2) each bit of the first input is multiplied by all the second input bits, and // 3) given the "bit location value", shifted to left. // 4) addition all result. uint32_t multiplyBitResult[16] = { 0 }; uint32_t sumAllMultiplyBit = 0; uint16_t bitOfInt_a[16] = { 0 }; uint16_t bitOfInt_b[16] = { 0 }; //1) bit-by-bit separation bitOfInt_a[0] = (a & 0b0000000000000001); bitOfInt_a[1] = ((a & 0b0000000000000010) >> 1); bitOfInt_a[2] = ((a & 0b0000000000000100) >> 2); bitOfInt_a[3] = ((a & 0b0000000000001000) >> 3); bitOfInt_a[4] = ((a & 0b0000000000010000) >> 4); bitOfInt_a[5] = ((a & 0b0000000000100000) >> 5); bitOfInt_a[6] = ((a & 0b0000000001000000) >> 6); bitOfInt_a[7] = ((a & 0b0000000010000000) >> 7); bitOfInt_a[8] = ((a & 0b0000000100000000) >> 8); bitOfInt_a[9] = ((a & 0b0000001000000000) >> 9); bitOfInt_a[10] = ((a & 0b0000010000000000) >> 10); bitOfInt_a[11] = ((a & 0b0000100000000000) >> 11); bitOfInt_a[12] = ((a & 0b0001000000000000) >> 12); bitOfInt_a[13] = ((a & 0b0010000000000000) >> 13); bitOfInt_a[14] = ((a & 0b0100000000000000) >> 14); bitOfInt_a[15] = ((a & 0b1000000000000000) >> 15); // bitOfInt_b[0] = (b & 0b0000000000000001); bitOfInt_b[1] = ((b & 0b0000000000000010) >> 1); bitOfInt_b[2] = ((b & 0b0000000000000100) >> 2); bitOfInt_b[3] = ((b & 0b0000000000001000) >> 3); bitOfInt_b[4] = ((b & 0b0000000000010000) >> 4); bitOfInt_b[5] = ((b & 0b0000000000100000) >> 5); bitOfInt_b[6] = ((b & 0b0000000001000000) >> 6); bitOfInt_b[7] = ((b & 0b0000000010000000) >> 7); bitOfInt_b[8] = ((b & 0b0000000100000000) >> 8); bitOfInt_b[9] = ((b & 0b0000001000000000) >> 9); bitOfInt_b[10] = ((b & 0b0000010000000000) >> 10); bitOfInt_b[11] = ((b & 0b0000100000000000) >> 11); bitOfInt_b[12] = ((b & 0b0001000000000000) >> 12); bitOfInt_b[13] = ((b & 0b0010000000000000) >> 13); bitOfInt_b[14] = ((b & 0b0100000000000000) >> 14); bitOfInt_b[15] = ((b & 0b1000000000000000) >> 15); //2 and 3) each bit of the first input is multiplied by all the second input bits, and given the "bit location value", shifted to left '<<'. multiplyBitResult[0] = assist_Multiply(bitOfInt_a[0], bitOfInt_b); multiplyBitResult[1] = ((assist_Multiply(bitOfInt_a[1], bitOfInt_b)) << 1); multiplyBitResult[2] = ((assist_Multiply(bitOfInt_a[2], bitOfInt_b)) << 2); multiplyBitResult[3] = ((assist_Multiply(bitOfInt_a[3], bitOfInt_b)) << 3); multiplyBitResult[4] = ((assist_Multiply(bitOfInt_a[4], bitOfInt_b)) << 4); multiplyBitResult[5] = ((assist_Multiply(bitOfInt_a[5], bitOfInt_b)) << 5); multiplyBitResult[6] = ((assist_Multiply(bitOfInt_a[6], bitOfInt_b)) << 6); multiplyBitResult[7] = ((assist_Multiply(bitOfInt_a[7], bitOfInt_b)) << 7); multiplyBitResult[8] = ((assist_Multiply(bitOfInt_a[8], bitOfInt_b)) << 8); multiplyBitResult[9] = ((assist_Multiply(bitOfInt_a[9], bitOfInt_b)) << 9); multiplyBitResult[10] = ((assist_Multiply(bitOfInt_a[10], bitOfInt_b)) << 10); multiplyBitResult[11] = ((assist_Multiply(bitOfInt_a[11], bitOfInt_b)) << 11); multiplyBitResult[12] = ((assist_Multiply(bitOfInt_a[12], bitOfInt_b)) << 12); multiplyBitResult[13] = ((assist_Multiply(bitOfInt_a[13], bitOfInt_b)) << 13); multiplyBitResult[14] = ((assist_Multiply(bitOfInt_a[14], bitOfInt_b)) << 14); multiplyBitResult[15] = ((assist_Multiply(bitOfInt_a[15], bitOfInt_b)) << 15); //4) addition all result. sumAllMultiplyBit = multiplyBitResult[0]; sumAllMultiplyBit = addition(sumAllMultiplyBit, multiplyBitResult[1]); sumAllMultiplyBit = addition(sumAllMultiplyBit, multiplyBitResult[2]); sumAllMultiplyBit = addition(sumAllMultiplyBit, multiplyBitResult[3]); sumAllMultiplyBit = addition(sumAllMultiplyBit, multiplyBitResult[4]); sumAllMultiplyBit = addition(sumAllMultiplyBit, multiplyBitResult[5]); sumAllMultiplyBit = addition(sumAllMultiplyBit, multiplyBitResult[6]); sumAllMultiplyBit = addition(sumAllMultiplyBit, multiplyBitResult[7]); sumAllMultiplyBit = addition(sumAllMultiplyBit, multiplyBitResult[8]); sumAllMultiplyBit = addition(sumAllMultiplyBit, multiplyBitResult[9]); sumAllMultiplyBit = addition(sumAllMultiplyBit, multiplyBitResult[10]); sumAllMultiplyBit = addition(sumAllMultiplyBit, multiplyBitResult[11]); sumAllMultiplyBit = addition(sumAllMultiplyBit, multiplyBitResult[12]); sumAllMultiplyBit = addition(sumAllMultiplyBit, multiplyBitResult[13]); sumAllMultiplyBit = addition(sumAllMultiplyBit, multiplyBitResult[14]); sumAllMultiplyBit = addition(sumAllMultiplyBit, multiplyBitResult[15]); return sumAllMultiplyBit; } uint32_t assist_Multiply(const uint16_t a, const uint16_t* const b) { //test with visual studio is ok. uint32_t result = 0; //each bit of the first input is multiplied by all the second input bits. (Note: multiplied in bit = '&') result |= (a & b[0]); result |= ((a & b[1]) << 1); result |= ((a & b[2]) << 2); result |= ((a & b[3]) << 3); result |= ((a & b[4]) << 4); result |= ((a & b[5]) << 5); result |= ((a & b[6]) << 6); result |= ((a & b[7]) << 7); result |= ((a & b[8]) << 8); result |= ((a & b[9]) << 9); result |= ((a & b[10]) << 10); result |= ((a & b[11]) << 11); result |= ((a & b[12]) << 12); result |= ((a & b[13]) << 13); result |= ((a & b[14]) << 14); result |= ((a & b[15]) << 15); return result; } uint32_t addition(const uint32_t x, const uint32_t y) { //test with visual studio is ok. uint32_t positiveCarry = 0; uint32_t a = x; uint32_t b = y; uint32_t result = 0; //run func 'assist_Addition()' for data bit ==> now data is (uint16_t + uint16_t) so 16+16=32 bit so need run func 'assist_Addition()' for 32 turn. assist_Addition(&a, &b, &positiveCarry); //1 assist_Addition(&a, &b, &positiveCarry); //2 assist_Addition(&a, &b, &positiveCarry); //3 assist_Addition(&a, &b, &positiveCarry); //4 assist_Addition(&a, &b, &positiveCarry); //5 assist_Addition(&a, &b, &positiveCarry); //6 assist_Addition(&a, &b, &positiveCarry); //7 assist_Addition(&a, &b, &positiveCarry); //8 assist_Addition(&a, &b, &positiveCarry); //9 assist_Addition(&a, &b, &positiveCarry); //10 assist_Addition(&a, &b, &positiveCarry); //11 assist_Addition(&a, &b, &positiveCarry); //12 assist_Addition(&a, &b, &positiveCarry); //13 assist_Addition(&a, &b, &positiveCarry); //14 assist_Addition(&a, &b, &positiveCarry); //15 assist_Addition(&a, &b, &positiveCarry); //16 assist_Addition(&a, &b, &positiveCarry); //17 assist_Addition(&a, &b, &positiveCarry); //18 assist_Addition(&a, &b, &positiveCarry); //19 assist_Addition(&a, &b, &positiveCarry); //20 assist_Addition(&a, &b, &positiveCarry); //21 assist_Addition(&a, &b, &positiveCarry); //22 assist_Addition(&a, &b, &positiveCarry); //23 assist_Addition(&a, &b, &positiveCarry); //24 assist_Addition(&a, &b, &positiveCarry); //25 assist_Addition(&a, &b, &positiveCarry); //26 assist_Addition(&a, &b, &positiveCarry); //27 assist_Addition(&a, &b, &positiveCarry); //28 assist_Addition(&a, &b, &positiveCarry); //29 assist_Addition(&a, &b, &positiveCarry); //30 assist_Addition(&a, &b, &positiveCarry); //31 result = assist_Addition(&a, &b, &positiveCarry); //32 return result; } uint32_t assist_Addition(uint32_t * const a, uint32_t * const b, uint32_t* const positiveCarry) { //test with visual studio is ok. (*positiveCarry) = (*a) & (*b); //1) get common bit of (a and b). (for find carry bit location) (*a) = (*a) ^ (*b); //2)'xor' between (a and b).(for Addition bit-to-bit) (*b) = (*positiveCarry) << 1; //3) "carry" shifted right for in carry place , till ready for summation. return (*a); } uint32_t subtraction(const uint32_t x, const uint32_t y) { //test with visual studio is ok. uint32_t negativeCarry = 0; uint32_t a = x; uint32_t b = y; uint32_t result = 0; //run func 'assist_Subtraction()' for data bit ==> now data is (uint16_t - uint16_t) so minimum input=16 bit so need run func 'assist_Subtraction()' for 16 turn. assist_Subtraction(&a, &b, &negativeCarry); //1 assist_Subtraction(&a, &b, &negativeCarry); //2 assist_Subtraction(&a, &b, &negativeCarry); //3 assist_Subtraction(&a, &b, &negativeCarry); //4 assist_Subtraction(&a, &b, &negativeCarry); //5 assist_Subtraction(&a, &b, &negativeCarry); //6 assist_Subtraction(&a, &b, &negativeCarry); //7 assist_Subtraction(&a, &b, &negativeCarry); //8 assist_Subtraction(&a, &b, &negativeCarry); //9 assist_Subtraction(&a, &b, &negativeCarry); //10 assist_Subtraction(&a, &b, &negativeCarry); //11 assist_Subtraction(&a, &b, &negativeCarry); //12 assist_Subtraction(&a, &b, &negativeCarry); //13 assist_Subtraction(&a, &b, &negativeCarry); //14 assist_Subtraction(&a, &b, &negativeCarry); //15 assist_Subtraction(&a, &b, &negativeCarry); //16 assist_Subtraction(&a, &b, &negativeCarry); //17 assist_Subtraction(&a, &b, &negativeCarry); //18 assist_Subtraction(&a, &b, &negativeCarry); //19 assist_Subtraction(&a, &b, &negativeCarry); //20 assist_Subtraction(&a, &b, &negativeCarry); //21 assist_Subtraction(&a, &b, &negativeCarry); //22 assist_Subtraction(&a, &b, &negativeCarry); //23 assist_Subtraction(&a, &b, &negativeCarry); //24 assist_Subtraction(&a, &b, &negativeCarry); //25 assist_Subtraction(&a, &b, &negativeCarry); //26 assist_Subtraction(&a, &b, &negativeCarry); //27 assist_Subtraction(&a, &b, &negativeCarry); //28 assist_Subtraction(&a, &b, &negativeCarry); //29 assist_Subtraction(&a, &b, &negativeCarry); //30 assist_Subtraction(&a, &b, &negativeCarry); //31 result = assist_Subtraction(&a, &b, &negativeCarry); //32 return result; } uint32_t assist_Subtraction(uint32_t* const a, uint32_t* const b, uint32_t* const negativeCarry) { //test with visual studio is ok. (*negativeCarry) = ( (~(*a)) & (*b) ); //1) get not common bit of (a and b). (for find carry bit location) (*a) = (*a) ^ (*b); //2)'xor' between (a and b).(for Subtraction bit-to-bit) (*b) = (*negativeCarry) << 1; //3) "carry" shifted left for in carry place , till ready for summation.(summation: Subtraction equal summation between positive and negative value) return (*a); } |
نفر نهم آقای علی ترابی
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 | #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include <stdint.h> //bit extract from int a,b and result in buffa,buffb char buffa,buffb; void bits(unsigned int a,unsigned int b,char s) { unsigned int cc,dd; //////a bit extract cc=1<<s; cc=a&cc; buffa=cc>>s; ///////b bit extract dd=1<<s; dd=bⅆ buffb=dd>>s; } //bit extract from int a,b and result in buffa,buffb char ab1(unsigned int x,unsigned int y,char ss) { bits(x,y,ss); ///////a>b bit buffb=buffb^1; return buffa&buffb; } //a>b char ab2(unsigned int x,unsigned int y,char ss) { unsigned int buff[2]; bits(x,y,ss); ///////a=b bit buff[0]=buffa; buff[1]=buffb; buffa=buffa^1; buffb=buffb^1; buffa=buffa&buffb; buffb=buff[0]&buff[1]; return buffa|buffb; } //a=b unsigned int zMax(unsigned int x,unsigned int y) { unsigned int res,x1,y1; char ba1[16]; x1=x; y1=y; ba1[0] = ab1(x,y,15); ba1[1] = ab2(x,y,15) & ab1(x,y,14); ba1[2] = ab2(x,y,15) & ab2(x,y,14) & ab1(x,y,13) ; ba1[3] = ab2(x,y,15) & ab2(x,y,14) & ab2(x,y,13) & ab1(x,y,12); ba1[4] = ab2(x,y,15) & ab2(x,y,14) & ab2(x,y,13) & ab2(x,y,12) & ab1(x,y,11); ba1[5] = ab2(x,y,15) & ab2(x,y,14) & ab2(x,y,13) & ab2(x,y,12) & ab2(x,y,11) & ab1(x,y,10); ba1[6] = ab2(x,y,15) & ab2(x,y,14) & ab2(x,y,13) & ab2(x,y,12) & ab2(x,y,11) & ab2(x,y,10) & ab1(x,y,9); ba1[7] = ab2(x,y,15) & ab2(x,y,14) & ab2(x,y,13) & ab2(x,y,12) & ab2(x,y,11) & ab2(x,y,10) & ab2(x,y,9) & ab1(x,y,8); ba1[8] = ab2(x,y,15) & ab2(x,y,14) & ab2(x,y,13) & ab2(x,y,12) & ab2(x,y,11) & ab2(x,y,10) & ab2(x,y,9) & ab2(x,y,8) & ab1(x,y,7); ba1[9] = ab2(x,y,15) & ab2(x,y,14) & ab2(x,y,13) & ab2(x,y,12) & ab2(x,y,11) & ab2(x,y,10) & ab2(x,y,9) & ab2(x,y,8) & ab2(x,y,7) & ab1(x,y,6); ba1[10] = ab2(x,y,15) & ab2(x,y,14) & ab2(x,y,13) & ab2(x,y,12) & ab2(x,y,11) & ab2(x,y,10) & ab2(x,y,9) & ab2(x,y,8) & ab2(x,y,7) & ab2(x,y,6) & ab1(x,y,5); ba1[11] = ab2(x,y,15) & ab2(x,y,14) & ab2(x,y,13) & ab2(x,y,12) & ab2(x,y,11) & ab2(x,y,10) & ab2(x,y,9) & ab2(x,y,8) & ab2(x,y,7) & ab2(x,y,6) & ab2(x,y,5) & ab1(x,y,4); ba1[12] = ab2(x,y,15) & ab2(x,y,14) & ab2(x,y,13) & ab2(x,y,12) & ab2(x,y,11) & ab2(x,y,10) & ab2(x,y,9) & ab2(x,y,8) & ab2(x,y,7) & ab2(x,y,6) & ab2(x,y,5) & ab2(x,y,4) & ab1(x,y,3); ba1[13] = ab2(x,y,15) & ab2(x,y,14) & ab2(x,y,13) & ab2(x,y,12) & ab2(x,y,11) & ab2(x,y,10) & ab2(x,y,9) & ab2(x,y,8) & ab2(x,y,7) & ab2(x,y,6) & ab2(x,y,5) & ab2(x,y,4) & ab2(x,y,3) & ab1(x,y,2); ba1[14] = ab2(x,y,15) & ab2(x,y,14) & ab2(x,y,13) & ab2(x,y,12) & ab2(x,y,11) & ab2(x,y,10) & ab2(x,y,9) & ab2(x,y,8) & ab2(x,y,7) & ab2(x,y,6) & ab2(x,y,5) & ab2(x,y,4) & ab2(x,y,3) & ab2(x,y,2) & ab1(x,y,1); ba1[15] = ab2(x,y,15) & ab2(x,y,14) & ab2(x,y,13) & ab2(x,y,12) & ab2(x,y,11) & ab2(x,y,10) & ab2(x,y,9) & ab2(x,y,8) & ab2(x,y,7) & ab2(x,y,6) & ab2(x,y,5) & ab2(x,y,4) & ab2(x,y,3) & ab2(x,y,2) & ab2(x,y,1) & ab1(x,y,0); res=ba1[15] | ba1[14] | ba1[13] | ba1[12] | ba1[11] | ba1[10] | ba1[9] | ba1[8] | ba1[7] | ba1[6] | ba1[5] | ba1[4] | ba1[3] | ba1[2] | ba1[1] | ba1[0]; res|=(res<<1); res|=(res<<2); res|=(res<<4); res|=(res<<8); x1=x1&res; res=~res; y1=y1&res; return y1|x1; } //main compare //uint16_t zMax(uint16_t a,uint16_t b) //{ // // //} |
نفر دهم آقای پوریا
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 | #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include <stdint.h> /* ………………… | 2BIT | A0->| COMPARATOR A>B|-> A1->| A=B|-> B1->| A B0->| | ——————— */ typedef union { uint16_t number; struct { uint16_t bit0 : 1; uint16_t bit1 : 1; uint16_t bit2 : 1; uint16_t bit3 : 1; uint16_t bit4 : 1; uint16_t bit5 : 1; uint16_t bit6 : 1; uint16_t bit7 : 1; uint16_t bit8 : 1; uint16_t bit9 : 1; uint16_t bit10 : 1; uint16_t bit11 : 1; uint16_t bit12 : 1; uint16_t bit13 : 1; uint16_t bit14 : 1; uint16_t bit15 : 1; }bits; struct { uint16_t grt : 1; uint16_t equ : 1; uint16_t les : 1; uint16_t res : 13; }output; }uint16_parser_t; uint16_t comp2bit(bool num1_bit0, bool num1_bit1, bool num2_bit0, bool num2_bit1); uint16_t set_bit(bool bit_mask); uint16_t greater(uint16_t num1, uint16_t num2); uint16_t comp2bit(bool num1_bit0, bool num1_bit1, bool num2_bit0, bool num2_bit1) { uint16_parser_t temp; temp.number = 0; temp.output.grt = ((num1_bit1) & (~num2_bit1)) | ((~num2_bit0)&((num1_bit0&(~num2_bit1)) | (num1_bit0 & num1_bit1))); temp.output.les = ((~num1_bit1)&num2_bit1) | (num2_bit0 & num2_bit1 & (~num1_bit0)) | ((~num1_bit0)&(~num1_bit1)&num2_bit0); temp.output.equ = (~(num1_bit0 ^ num2_bit0)) & (~(num1_bit1 ^ num2_bit1)); return (uint16_t)(temp.number & (0x0007)); } uint16_t set_bit(bool bit_mask) { uint16_t temp = 0; temp |= (bit_mask << 0); temp |= (bit_mask << 1); temp |= (bit_mask << 2); temp |= (bit_mask << 3); temp |= (bit_mask << 4); temp |= (bit_mask << 5); temp |= (bit_mask << 6); temp |= (bit_mask << 7); temp |= (bit_mask << 8); temp |= (bit_mask << 9); temp |= (bit_mask << 10); temp |= (bit_mask << 11); temp |= (bit_mask << 12); temp |= (bit_mask << 13); temp |= (bit_mask << 14); temp |= (bit_mask << 15); return temp; } uint16_t zMax(uint16_t num1, uint16_t num2) { uint16_parser_t result, num1_temp, num2_temp; result.number = 0; num1_temp.number = num1; num2_temp.number = num2; result.number = comp2bit((bool)num1_temp.bits.bit0, (bool)num1_temp.bits.bit1, (bool)num2_temp.bits.bit0, (bool)num2_temp.bits.bit1); result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit2, (bool)result.output.les, (bool)num2_temp.bits.bit2); result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit3, (bool)result.output.les, (bool)num2_temp.bits.bit3); result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit4, (bool)result.output.les, (bool)num2_temp.bits.bit4); result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit5, (bool)result.output.les, (bool)num2_temp.bits.bit5); result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit6, (bool)result.output.les, (bool)num2_temp.bits.bit6); result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit7, (bool)result.output.les, (bool)num2_temp.bits.bit7); result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit8, (bool)result.output.les, (bool)num2_temp.bits.bit8); result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit9, (bool)result.output.les, (bool)num2_temp.bits.bit9); result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit10, (bool)result.output.les, (bool)num2_temp.bits.bit10); result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit11, (bool)result.output.les, (bool)num2_temp.bits.bit11); result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit12, (bool)result.output.les, (bool)num2_temp.bits.bit12); result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit13, (bool)result.output.les, (bool)num2_temp.bits.bit13); result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit14, (bool)result.output.les, (bool)num2_temp.bits.bit14); result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit15, (bool)result.output.les, (bool)num2_temp.bits.bit15); result.number = (set_bit((bool)result.output.grt) & num1) | (set_bit((bool)result.output.les) & num2) | (set_bit((bool)result.output.equ) & num1); return (uint16_t)result.number; } |
نفر یادهم آقای محسنیان
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 | #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include <stdint.h> #define _Ca(Ca,Cb,a,b) (( ((Ca ^ Cb) | (a | (~(a^b))) ) & Ca) >>1) #define _Cb(Ca,Cb,a,b) (( ((Ca ^ Cb) | (b | (~(a^b))) ) & Cb) >>1) #define bit(n) (((a & ca[n]) | (b & cb[n])) & (1<<(15-n)) ) uint16_t zMax(uint16_t a,uint16_t b) { uint16_t c; uint16_t ca[16]; uint16_t cb[16]; ca[0] = 1<<15; cb[0] = 1<<15; ca[1] = _Ca(ca[0],cb[0],a,b); cb[1] = _Cb(ca[0],cb[0],a,b); ca[2] = _Ca(ca[1],cb[1],a,b); cb[2] = _Cb(ca[1],cb[1],a,b); ca[3] = _Ca(ca[2],cb[2],a,b); cb[3] = _Cb(ca[2],cb[2],a,b); ca[4] = _Ca(ca[3],cb[3],a,b); cb[4] = _Cb(ca[3],cb[3],a,b); ca[5] = _Ca(ca[4],cb[4],a,b); cb[5] = _Cb(ca[4],cb[4],a,b); ca[6] = _Ca(ca[5],cb[5],a,b); cb[6] = _Cb(ca[5],cb[5],a,b); ca[7] = _Ca(ca[6],cb[6],a,b); cb[7] = _Cb(ca[6],cb[6],a,b); ca[8] = _Ca(ca[7],cb[7],a,b); cb[8] = _Cb(ca[7],cb[7],a,b); ca[9] = _Ca(ca[8],cb[8],a,b); cb[9] = _Cb(ca[8],cb[8],a,b); ca[10] = _Ca(ca[9],cb[9],a,b); cb[10] = _Cb(ca[9],cb[9],a,b); ca[11] = _Ca(ca[10],cb[10],a,b); cb[11] = _Cb(ca[10],cb[10],a,b); ca[12] = _Ca(ca[11],cb[11],a,b); cb[12] = _Cb(ca[11],cb[11],a,b); ca[13] = _Ca(ca[12],cb[12],a,b); cb[13] = _Cb(ca[12],cb[12],a,b); ca[14] = _Ca(ca[13],cb[13],a,b); cb[14] = _Cb(ca[13],cb[13],a,b); ca[15] = _Ca(ca[14],cb[14],a,b); cb[15] = _Cb(ca[14],cb[14],a,b); c = bit(0) | bit(1) | bit(2) | bit(3) | bit(4) | bit(5) | bit(6) | bit(7) | bit(8) | bit(9) | bit(10) | bit(11) | bit(12) | bit(13) | bit(14) | bit(15) ; return c; } |
نفر دوازدم آقای اصغر گرزین:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 | #include "iostream" using namespace std; uint16_t range1[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; uint16_t range2[16] = {15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}; // returns 0xFFFF if ith bit of x is 1 and ith bit of y is 0 // returns 0 ow uint16_t f1(uint16_t x){ uint16_t r = 0; for(auto i: range1){ r |= x << i; } return r; } // returns ith bit of x uint16_t f2(uint16_t x, uint16_t i){ return (x >> i) & 1; } // returns complement of ith bit of x uint16_t f3(uint16_t x, uint16_t i){ return ((x >> i) & 1) ^ 1; } uint16_t f(uint16_t x, uint16_t y, uint16_t a, uint16_t b, uint16_t i){ uint16_t d = 0xFFFF; a |= f1(f2(x, i) & f3(y, i)) & (d ^ b); return a; } // returns the maximum number uint16_t zMax(uint16_t x, uint16_t y) { uint16_t b = 0; uint16_t a = 0; // if x > y then set a = 0xFFFF and b = 0 // if y > x then set b = 0xFFFF and a = 0 for(auto i: range2){ a |= f(x, y, a, b, i); b |= f(y, x, b, a, i); } a |= ~b; // if x = y return x return (x & a) ^ (y & b); } |
نفر سیزدهم آقای احمد:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | #include <stdint.h> #include <stdbool.h> #include <stdio.h> bool comp(uint16_t x, uint16_t y); uint16_t zMax(uint16_t x, uint16_t y) { int r; char *Px=NULL; Px = &Px[x]; Px = &Px[~y]; Px = &Px[1]; r = Px; r = (r & (r >> 31)); Px=0; Px = &Px[~r]; Px = &Px[1]; r=Px; Px = 0; Px = &Px[x]; Px = &Px[r]; return Px; } |
نفر چهاردهم عنایت جوادی :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 | #include <stdint.h> #include <stdbool.h> #include <stdio.h> uint16_t zMax(uint16_t A, uint16_t B) { uint16_t ttmp[] = {A,B,A}; uint8_t len = 15; //16-1 uint16_t check = 1<<len; uint8_t a, b, m, x; a = (A&check)>>len; b = (B&check)>>len; //0000000000000001 m=(a^b)^1;//if m=1: (a == b), check the next bit //check = check>>m; A = A<<m; B = B<<m; // calculate a and b a = (A&check)>>len; b = (B&check)>>len; //0000000000000010 m=(a^b)^1;//if m=1: (a == b), check the next bit //check = check>>m; A = A<<m; B = B<<m; // calculate a and b a = (A&check)>>len; b = (B&check)>>len; //0000000000000100 m=(a^b)^1;//if m=1: (a == b), check the next bit //check = check>>m; A = A<<m; B = B<<m; // calculate a and b a = (A&check)>>len; b = (B&check)>>len; //0000000000001000 m=(a^b)^1;//if m=1: (a == b), check the next bit //check = check>>m; A = A<<m; B = B<<m; // calculate a and b a = (A&check)>>len; b = (B&check)>>len; //0000000000010000 m=(a^b)^1;//if m=1: (a == b), check the next bit //check = check>>m; A = A<<m; B = B<<m; // calculate a and b a = (A&check)>>len; b = (B&check)>>len; //0000000000100000 m=(a^b)^1;//if m=1: (a == b), check the next bit //check = check>>m; A = A<<m; B = B<<m; // calculate a and b a = (A&check)>>len; b = (B&check)>>len; //0000000001000000 m=(a^b)^1;//if m=1: (a == b), check the next bit //check = check>>m; A = A<<m; B = B<<m; // calculate a and b a = (A&check)>>len; b = (B&check)>>len; //0000000010000000 m=(a^b)^1;//if m=1: (a == b), check the next bit //check = check>>m; A = A<<m; B = B<<m; // calculate a and b a = (A&check)>>len; b = (B&check)>>len; //0000000100000000 m=(a^b)^1;//if m=1: (a == b), check the next bit //check = check>>m; A = A<<m; B = B<<m; // calculate a and b a = (A&check)>>len; b = (B&check)>>len; //0000001000000000 m=(a^b)^1;//if m=1: (a == b), check the next bit //check = check>>m; A = A<<m; B = B<<m; // calculate a and b a = (A&check)>>len; b = (B&check)>>len; //0000010000000000 m=(a^b)^1;//if m=1: (a == b), check the next bit //check = check>>m; A = A<<m; B = B<<m; // calculate a and b a = (A&check)>>len; b = (B&check)>>len; //0000100000000000 m=(a^b)^1;//if m=1: (a == b), check the next bit //check = check>>m; A = A<<m; B = B<<m; // calculate a and b a = (A&check)>>len; b = (B&check)>>len; //0001000000000000 m=(a^b)^1;//if m=1: (a == b), check the next bit //check = check>>m; A = A<<m; B = B<<m; // calculate a and b a = (A&check)>>len; b = (B&check)>>len; //0010000000000000 m=(a^b)^1;//if m=1: (a == b), check the next bit //check = check>>m; A = A<<m; B = B<<m; // calculate a and b a = (A&check)>>len; b = (B&check)>>len; //0100000000000000 m=(a^b)^1;//if m=1: (a == b), check the next bit //check = check>>m; A = A<<m; B = B<<m; // calculate a and b a = (A&check)>>len; b = (B&check)>>len; //1000000000000000 x = (a^b)^1; uint8_t index = ((a&(~b))^1)<<x; return ttmp[index]; } |
نفر پانزدهم آقا یا خانم M4M :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 | #include <stdint.h> #include <stdbool.h> #include <stdio.h> int32_t sub(int32_t x, int32_t y) { int32_t borrow; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; borrow = (~x) & y; x = x ^ y; y = borrow << 1; return x; } uint16_t zMax(uint16_t x, uint16_t y) { /*uint16_t a = (sub(x, y) >> (31)); uint16_t b = (x ^ y) & a; uint16_t result = x ^ b;*/ return x ^ ( (x ^ y) & (uint16_t)(sub(x, y) >> (31)) ); } |
نفر شانزدهم آقای معین :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | #include <stdint.h> #include <stdbool.h> #include <stdio.h> uint16_t Mm,Nn; char A(char a); char B(char b); char S(char d); uint16_t compare(void); char A(char a)//give the bite that we want in first number { return (Mm&(1<<a))>>a; } char B(char b)//give the bite that we want in second number { return (Nn&(1<<b))>>b; } char S(char d)//give XNOR of two bite { return (~(A(d) ^ B(d)))&1; } uint16_t compare(void) { uint16_t flag = A(15)&(~B(15)) | S(15)&A(14)&(~B(14)) | S(15)&S(14)&A(13)&(~B(13)) | S(15)&S(14)&S(13)&A(12)&(~B(12)) | S(15)&S(14)&S(13)&S(12)&A(11)&(~B(11)) | S(15)&S(14)&S(13)&S(12)&S(11)&A(10)&(~B(10)) | S(15)&S(14)&S(13)&S(12)&S(11)&S(10)&A(9)&(~B(9)) | S(15)&S(14)&S(13)&S(12)&S(11)&S(10)&S(9)&A(8)&(~B(8)) | S(15)&S(14)&S(13)&S(12)&S(11)&S(10)&S(9)&S(8)&A(7)&(~B(7)) | S(15)&S(14)&S(13)&S(12)&S(11)&S(10)&S(9)&S(8)&S(7)&A(6)&(~B(6)) | S(15)&S(14)&S(13)&S(12)&S(11)&S(10)&S(9)&S(8)&S(7)&S(6)&A(5)&(~B(5)) | S(15)&S(14)&S(13)&S(12)&S(11)&S(10)&S(9)&S(8)&S(7)&S(6)&S(5)&A(4)&(~B(4)) | S(15)&S(14)&S(13)&S(12)&S(11)&S(10)&S(9)&S(8)&S(7)&S(6)&S(5)&S(4)&A(3)&(~B(3)) | S(15)&S(14)&S(13)&S(12)&S(11)&S(10)&S(9)&S(8)&S(7)&S(6)&S(5)&S(4)&S(3)&A(2)&(~B(2)) | S(15)&S(14)&S(13)&S(12)&S(11)&S(10)&S(9)&S(8)&S(7)&S(6)&S(5)&S(4)&S(3)&S(2)&A(1)&(~B(1)) | S(15)&S(14)&S(13)&S(12)&S(11)&S(10)&S(9)&S(8)&S(7)&S(6)&S(5)&S(4)&S(3)&S(2)&S(1)&A(0)&(~B(0)); flag = flag<<15 | flag<<14 | flag<<13 | flag<<12 | flag<<11 | flag<<10 | flag<<9 | flag<<8 | flag<<7 | flag<<6 | flag<<5 | flag<<4 | flag<<3 | flag<<2 | flag<<1 | flag<<0; return ((Mm&flag) | (Nn&(~flag))); } |
نفر هفدهم آقای سوران:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 | #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include <stdint.h> unsigned int CCi(unsigned int a, unsigned int b, unsigned char i); unsigned int Yi(unsigned int a, unsigned int b, unsigned char i); unsigned int retMax(unsigned int A, unsigned int B); unsigned int CCi(unsigned int a, unsigned int b, unsigned char i) { unsigned int xNor; unsigned int C,CCi; xNor=~(a^b); //C= xNor&(1<<i); C= (xNor&(1<<i))>>i; CCi=(C<<15)|(C<<14)|(C<<13)|(C<<12)|(C<<11)|(C<<10)|(C<<9)|(C<<8)|(C<<7)|(C<<6)|(C<<5)|(C<<4)|(C<<3)|(C<<2)|(C<<1)| C; return CCi; } unsigned int Yi(unsigned int a, unsigned int b, unsigned char i) { unsigned int D,Y; D=(0xffff<<i); Y=D|CCi(a,b,i); return Y; } unsigned int zMax(unsigned int A, unsigned int B) { unsigned int T; bool bit; T=(A&(~B))&Yi(A,B,15)&Yi(A,B,14)&Yi(A,B,13)&Yi(A,B,12)&Yi(A,B,11)&Yi(A,B,10)&Yi(A,B,9)&Yi(A,B,8)&Yi(A,B,7)&Yi(A,B,6)&Yi(A,B,5)&Yi(A,B,4)&Yi(A,B,3)&Yi(A,B,2)&Yi(A,B,1); bit=(bool)T; T=(bit<<15)|(bit<<14)|(bit<<13)|(bit<<12)|(bit<<11)|(bit<<10)|(bit<<9)|(bit<<8)|(bit<<7)|(bit<<6)|(bit<<5)|(bit<<4)|(bit<<3)|(bit<<2)|(bit<<1)| bit; return (T&A) | (~T)&B; } |
اعلام برنده های مسابقه:
خب بعد از بررسی های کاملتر و اینکه جواب برخی هم به عنوان هرزنامه شناخته شده بود تعداد جوابهای صحیح 17 نفری شدند که ما بصورت نرم افزاری قرعه کشی کردیم و دو نفر از دوستان به عنوان برنده انتخاب شدند:
قرعه کشی مسابقه
و برنده ها عبارتند از آقایان :
- نفر نهم آقای علی ترابی
- نفر سیزدهم آقای احمد
ممنون میشم دوستان برنده به آی دی تلگرام سیسوگ @Sisoogos پیغام بدند تا جایزه خدمتشون ارائه بشه.
سلام عید مبارک
مسابقه جالبی بود
کوتاهترین پاسخ مال خود سیسوگه که حدود 10 خط و طولانی ترینش هم 325 خطه!!!!!!!!!!!!!!!!!!!!!!
وقتی مسابقه رو دیدم وقت نداشتم فکر کنم فقط شروع کردم به کد زدن، حاصل کد بدون فکر شده 32 برابر که این باعث میشه توی یه برنامه واقعی معایب زیر رو داشته باشیم:
1) حجم فلش مصرفی زیاد
2) سرعت اجرا بشدت کند
3) حافظه اشغالی برای stack بدلیل فراخونی ها زیاد بشه
4) رم اسفاده شده هم زیاد بشه
—————
دوست عزیزی که این مسابقه رو بی ارزش دونستن:
مزایای همچین مسابقه ای:
1) حس رقابت بین برنامه نویسان که نتیجش افزایش خلاقیت میشه
2) نشون دادن اینکه برای انجام یه هدف حداقل چقدر میشه راه حل داشته باشیم
3) ارتباط بیشتر برنامه نویسان با هم
4) نکته مهم: زبان c یه زبان خاصه، چون این قابلیت رو داره که دستورات جدیدی باهاش ساخت و این همون دلیلیه که اکثر زبان های جدید بیسشون زبان c هست و زمانی که شما بخواین یه دستور جدید تولید کنید دقیقا به چالشی مثل همین مسابقه روبه رو میشین چرا که در این مسابقه با کنار گذاشتن دستورات پایه شما رو مجبور میکنه که اون دستورات رو خودتون بسازید، حالا مگه پیش میاد که ما بخوایم یه دستور جدید بسازیم؟
بله
مخصوصا زمانی که بخواین به سخت افزار ها نفوذ کنید، یا بخواید مسایلی رو حل کنید که محدودیت هایی توی زبان c و زبان های های دیگه وجود داره که این قسمت بیشتر برای بخش R&D (تحقیق و توسعه) شرکت ها پیش میاد.
دوستان سیسوگی بابت این مسابقه و هزینه (مالی و زمانی) که بابتش کردید دومو آریگاتو گوزایماشتا، دوزو…
سلام عید شما هم مبارک و بابت انرژی که تزریق کردید
ممنون بابت توضیحات کاملتون 🙂 و جوابی که به جای ما دادید :-))
سلام
من دو لینک فرستاده بودم که برای کد و توضیح بود ولی ارسال نشده 🙁
عجیبه واقعا ، با ایدی تلگرام سیسوگ در ارتباط باشید
گفتن که کامنتم رفته توی هرزنامه چون لینک داشته، و برسی خواهیم کرد کد رو
بسیار عالی امروز بررسی میکنم کد های جا مونده رو
به نظرم این مسابقه در واقع هیچ ربطی به دانش زبان سی و کد نویسی نرم افزاری ندارد
اینکه قابلیت های اصلی زبان رو ازش بگیریم و بخواهیم یک مساله رو حل کنیم هرگز در دنیای حقیقی واقع نخواهد شد.
در واقع یکطور هنرنمایی است. یا یک استفاده غیر معمول از سی برای توصیف سخت افزار.
به نظرم بی ارزشه
ممنون از نظر شما دوست عزیز
مگه نگفتید شرط استفاده نشه؟ بجز جواب فونیکس همشون از if استفاده کردند چرا؟!
اون قسمت کدی هست که ما نوشتیم تا حالتهای مختلف را تست کنیم و جزء تابع نیست
طبق جمله زیر که بیان فرمودید
“همونطور که بیشتر دوستان حدس زدند برای حل این مساله باید دست به دامن گیت های دیجیتال شد و دقیقا مشابه کاری که توی ALU برای مقایسه بین اعداد انجام میشه رو اینجا پیاده سازی کنیم. که در واقع این میشه راه مستقیم و یه راه غیر مستفیم هم وجود داره که میشه پیاده سازی توابع جمع و تفریق با کمک گیت های منطقی و استفاده از آنها مطابق معادلات ریاضی مربوطه.”
بنده بهترین کد رو نوشتم و فقط از گیت های منطقی برای پیاده سازی عمل تفریق استفاده کردم و از آنجا که میدانستم عدد 16 بیتی هست بنده حاصلضرب sizeof(int) * 8 را برابر 32 دیگر نوشتم و البته میتوانستم عمل ضرب را نیز با گیت های منطقی و بدون هیچگونه شرطی پیاده سازی کنم. و کد بنده به شرح زیر نیز هست و کلیه قوانینم بیشتر همه رعایت کردم و درصورتی که اکثر جوابهایی که صحیح بیان کردید همه از دستور IF و حلقه FOR باشرط استفاده کرده اند. میتوانید این نظر را نیز با بقیه دوستان به اشتراک بزارید. اگر جواب بنده صحیح نباشه واقعا چالش مسخره ای است. چون من همه قوانین را رعایت کردم.
#include
// Subtraction two numbers without using the ‘-‘ operator
int subtract(int x, int y)
{
// Iterate till there
// is no carry
while (y)
{
// borrow contains common
// set bits of y and unset
// bits of x
int borrow = (~x) & y;
// Subtraction of bits of x
// and y where at least one
// of the bits is not set
x = x ^ y;
// Borrow is shifted by one
// so that subtracting it from
// x gives the required sum
y = borrow <> (sizeof(int) * 8 – 1)));
// sizeof(int) = 4 byte =====> 4*8 = 32
return subtract(x,(subtract(x,y) & (subtract(x,y) >> subtract(32,1))));
}
int main()
{
int x,y;
printf (“Please enter a : “);
scanf(“%d”,&x);
printf (“Please enter b : “);
scanf(“%d”,&y);
printf(“Max is %d”, Max(x, y));
return 0;
}
سلام دوست عزیز فکر میکنم سوءتفاهم پیش آمده و لازمه توضیحاتی و خدمتتون بدم که این مساله حل بشه !
توضیح اول در خصوص وجود if و for در کدهای : در واقع این کد ها کد های تست بنده برای بررسی عملکرد صحیح توابع ارسالی است – تمام حالت های ورودی A,B رو به توابع دوستان میدیم و با مقدار بزرگتر چک میکنیم ! اگر اختلافی وجود داشته باشه لاگ میگیریم. که دوستان به اشتباه اون تست کد رو بع عنوان کد دوستان منتشر کردن! توابع ارسالی دوستان تابع zMax هست اگه توی اون توابع تناقض پیدا کردید حق با شماست.
توضیح دوم در خصوص وجود حلقه توی کد شما و چرایی این که چرا قابل پذیرش نیست : ببینید توی کد یکی از دوستان حلقه به شکل زیر استفاده شده
for(int i=0; i<16; i++) AgB |= (AcoB <
شما عرض نکردید که از حلقه ها نمیتوان استفاده کرد و فقط گفتید از علامتهایی که بیان کردید نمیتوان داخل شرط حلقه استفاده کرد که منم استفاده نکردم. من تنها از کلمه y در حلقه ام استفاده کرده ام فقط همین ، و در نظرم طبق توضیحاتتون بنظرم درست میومد چون از هیچ علامت شرطی ای داخل حلقه استفاده نکردم. این مثالی هم که از دوستمان زدید خب اگر میتوانست بدون حلقه و علامت کوچکتر مینوشت اما بنظر بنده چون علامت کوچکتر گذاشته اند باید پاسخشان غلط در نظر گرفته شود. در کل در انتخاب درست و غلطی جواب بنده خود مختارید و هنوز طبق شرایطی که بیان کرده بودید بنظرم درست است. مگر اینکه داخل شرایط بیان کنید استفاده از حلقه ها هم مطلقا ممنوعه.
موفق باشید
ذکر کردم {حتی شرط‌های درون بدنه حلقه} ! صرفا این معنی بکار بردن علامت نیست ! حتی نفس شرط هم مشکل داره که شما استفاده کردید
می تونستند! توی کامنتشون هم دقیقا اشاره کردند :
این موضوع رو بعد یک کامنت بودن حلقه هم گذاشتن! اگر کامنت ها رو جستجو کنید دقیقا مواردی رو که اشاره کردم پیدا میکنید
شما اگر می تونسنید حلقتون رو باز می کردید ! وقتی این کار انجام نشده یعنی شرایط مسابقه رو زیر پا گذاشتید.
پس برنامه من کو ؟ چون زیاد بود با لینک ارسال کردم
دوست عزیز کمی صبور باشید تعداد پاسخ ها خیلی زیاد بودند هنوز نیمی از اونها هم بررسی نشده
حتما
typedef enum{
true,
false
}bool;
unsigned int larg_uint( unsigned int a,unsigned int b);
int main()
{
printf(“\n\n number is : %d”, larg_uint(2000,200));
}
unsigned int larg_uint(unsigned int a,unsigned int b){
unsigned int arr[]={a,b};
return arr[((bool)(b>>a))];
}
سلام با این که تایم تمام شده ولی من بررسی کردم کد رو برای ورودی های زیر درست کار نکرد
A=2,B=3 Max=2
A=3,B=4 Max=3
A=3,B=5 Max=3
A=3,B=6 Max=3
A=3,B=7 Max=3
https://paste.ubuntu.com/p/MsKW6fS83v/
سلام میدونم وقت تموم شده اما خواستم راه خودم رو به صورت تمیز و خلاصه شده هم بفرستم. برای درک ساده تر.
البته میدونم که نوشتن for یک کوچولو تقلب حساب میشه چون این نوع for هم درون خودش شرط پایان رو چک میکنه. اما چون به راحتی میشه این for رو باز کرد و دو خطی که توش هست رو برای مقادیر مختلف “i” نوشت (همونطوری که دیشب بدون for این سوال رو حل کردم)، من این تقلب کوچولو رو کردم که فقط کد تمیزتر بشه.
اوکی مشکلی نداشت – توی کامنت توضیح دادم که چون میشه حلقه رو باز کرد مشکلی نداره استفاده ازش
ممنون این کد بهتری است 🙂
https://repl.it/@ehsan00m/test
سلام پاسخ رو توی لینک بالا گذاشتم ایده کار هم مشابه مدار مقایسه کننده چهار بیتی که در کتاب مدار منطقی مانو هست
فکر کنم جواب من رو نخوندین به همه ی کامنتا جواب دادین
اوپس – ببخشید تعداد کامنت ها زیاد بوده فاموش کردم – الان بررسی می کنم
خوب بررسی کردم تابعتون رو توی کد تست قرار دادم
https://onlinegdb.com/S1zkz3EUI
برای ورودی های زیر خروجی مناسب نداشت :
A=0,B=1 Max=0
A=2,B=3 Max=2
A=4,B=5 Max=4
A=6,B=7 Max=6
A=8,B=9 Max=8
جواب من که با for نوشته شده با مشکل پیست میشه. اگه مایلین یک طریق دیگه واسه فرستادنش پیشنهاد بدین که از اون طریق بفرستم.
سلام دوست عزیز میتونید به ادرس زیر رفته و اونجا کدتون را بگذارید و لینکش را ارسال کنید
https://paste.ubuntu.com/p/9trBWbkq5h/
جواب من
بلاخره کد صحیح رو گرفتیم :))
کد به خوبی کار میکرد
تست کد : https://pastecode.xyz/view/a4a75b43
+ از اونجایی که حلقه رو با میشه جایگزین تکرار کرد مشکلی نداره وجود حلقه در این کد
جواب من که با for نوشته شده با مشکل پیست میشه. اگه مایلین یک طریق دیگه واسه فرستادنش پیشنهاد بدین
کد من باز هم با مشکل پیست شد. احتمالا مشکل از کامپوننت شماست.
کد رو توی سایت https://pastecode.xyz/ بذارید
// متوجه شدم که کد اولم توی کپی پیست با مشکل کپی شد. پس دوباره فرستادم
#include “iostream”
using namespace std;
uint16_t range1[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
uint16_t range2[16] = {15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
// if x = 0 returns 0
// if x = 1 returns 0xFFF
uint16_t f1(uint16_t x){
uint16_t r = 0;
for(auto i: range1){
r |= x <> i) & 1;
}
// returns complement of ith bit of x
uint16_t f3(uint16_t x, uint16_t i){
return ((x >> i) & 1) ^ 1;
}
// returns 0xFFFF if ith bit of x is 1 and ith bit of y is 0
// returns 0 ow
uint16_t f(uint16_t x, uint16_t y, uint16_t a, uint16_t b, uint16_t i){
uint16_t d = 0xFFFF;
a |= f1(f2(x, i) & f3(y, i)) & (d ^ b);
return a;
}
// returns the maximum number
uint16_t maximum(uint16_t x, uint16_t y) {
uint16_t b = 0;
uint16_t a = 0;
// if x > y then set a = 0xFFFF and b = 0
// if y > x then set b = 0xFFFF and a = 0
for(auto i: range2){
a |= f(x, y, a, b, i);
b |= f(y, x, b, a, i);
}
a |= ~b; // if x = y return x
return (x & a) ^ (y & b);
}
int main(){
cout << maximum(81, 18) << endl;
}
آقا یه ساعت بیشتر وقت بدی حل کردم
#include
using namespace std;
uint16_t Max(uint16_t A,uint16_t B)
{
//Ba Arzesh Tarin
char x0 =(A>>15)&1;
char x1 =(A>>14)&1;
char x2 =(A>>13)&1;
char x3 =(A>>12)&1;
char x4 =(A>>11)&1;
char x5 =(A>>10)&1;
char x6 =(A>>9)&1;
char x7 =(A>>8)&1;
char x8 =(A>>7)&1;
char x9 =(A>>6)&1;
char x10=(A>>5)&1;
char x11=(A>>4)&1;
char x12=(A>>3)&1;
char x13=(A>>2)&1;
char x14=(A>>1)&1;
char x15=(A)&1;
char y0 =(B>>15)&1;
char y1 =(B>>14)&1;
char y2 =(B>>13)&1;
char y3 =(B>>12)&1;
char y4 =(B>>11)&1;
char y5 =(B>>10)&1;
char y6 =(B>>9)&1;
char y7 =(B>>8)&1;
char y8 =(B>>7)&1;
char y9 =(B>>6)&1;
char y10=(B>>5)&1;
char y11=(B>>4)&1;
char y12=(B>>3)&1;
char y13=(B>>2)&1;
char y14=(B>>1)&1;
char y15=(B)&1;
char r0= x0|y0;
char a0 = x0&(~y0);
char b0 = ~(x0)&y0;
char c0 = ~(a0^b0);
char a1 = x1&(~y1);
char b1 = (~x1)&y1;
char c1 = ~(a1^b1);
char a2 = x2&(~y2);
char b2= (~x2)&y2;
char c2 = ~(a2^b2);
char a3 = x3&(~y3);
char b3 = (~x)3&y3;
char c3 = ~(a3^b3);
char a4 = x4&(~y4);
char b4 = (~x4)&y4;
char c4 = ~(a4^b4);
char a5 = x5&(~y5);
char b5 = (~x5)&y5;
char c5 = ~(a5^b5);
char a6 = x6&(~y6);
char b6 = (~x6)&y6;
char c6 = ~(a6^b6);
char a7 = x7&(~y7);
char b7 = (~x7)&y7;
char c7 = ~(a7^b7);
char a8 = x8&(~y8);
char b8 = (~x8)&y8;
char c8 = ~(a8^b8);
char a9 = x9&(~y9);
char b9 = (~x9)&y9;
char c9 = ~(a9^b9);
char a10 = x10&(~y10);
char b10 = (~x10)&y10;
char c10 = ~(a10^b10);
char a11 = x11&(~y11);
char b11 = (~x11)&y11;
char c11 = ~(a11^b11);
char a12 = x12&(~y12);
char b12 = (~x12)&y12;
char c12 = ~(a12^b12);
char a13 = x13&(~y13);
char b13 = (~x13)&y13;
char c13 = ~(a13^b13);
char a14 = x14&(~y14);
char b14 = (~x14)&y14;
char c14 = ~(a14^b14);
char r1= (a0&x1) | (b0&y1) | (c0&y1);
char r2= ((a0|(c0&a1))&x2) | ((b0|(c0&b1))&y2) | (c1&y2);
char r3= ((a0|(c0&a1)|(c1&a2))&x3) | ((b0|(c0&b1)|(c1&b2))&y3) | (c2&y3);
char r4= ((a0|(c0&a1)|(c1&a2)|(c2&a3))&x4) | ((b0|(c0&b1)|(c1&b2)|(c2&b3))&y3) | (c3&y4);
char r5= ((a0|(c0&a1)|(c1&a2)|(c2&a3)|(c3&a4))&x5) | ((b0|(c0&b1)|(c1&b2)|(c2&b3)|(c3&b4))&y5) | (c4&y5);
char r6= ((a0|(c0&a1)|(c1&a2)|(c2&a3)|(c3&a4)|(c4&a5))&x6) | ((b0|(c0&b1)|(c1&b2)|(c2&b3)|(c3&b4)|(c4&b5))&y6) | (c5&y6);
char r7= ((a0|(c0&a1)|(c1&a2)|(c2&a3)|(c3&a4)|(c4&a5)|(c5&a6))&x7) | ((b0|(c0&b1)|(c1&b2)|(c2&b3)|(c3&b4)|(c4&b5)|(c5&b6))&y7) | (c6&y7);
char r8= ((a0|(c0&a1)|(c1&a2)|(c2&a3)|(c3&a4)|(c4&a5)|(c5&a6)|(c6&a7))&x8) | ((b0|(c0&b1)|(c1&b2)|(c2&b3)|(c3&b4)|(c4&b5)|(c5&b6)|(c6&b7))&y8) | (c7&y8);
char r9= ((a0|(c0&a1)|(c1&a2)|(c2&a3)|(c3&a4)|(c4&a5)|(c5&a6)|(c6&a7)|(c7&a8))&x9) | ((b0|(c0&b1)|(c1&b2)|(c2&b3)|(c3&b4)|(c4&b5)|(c5&b6)|(c6&b7)|(c7&b8))&y9) | (c8&y9);
char r10= ((a0|(c0&a1)|(c1&a2)|(c2&a3)|(c3&a4)|(c4&a5)|(c5&a6)|(c6&a7)|(c7&a8)|(c8&a9))&x10) | ((b0|(c0&b1)|(c1&b2)|(c2&b3)|(c3&b4)|(c4&b5)|(c5&b6)|(c6&b7)|(c7&b8)|(c8&b9))&y10) | (c9&y10);
char r11= ((a0|(c0&a1)|(c1&a2)|(c2&a3)|(c3&a4)|(c4&a5)|(c5&a6)|(c6&a7)|(c7&a8)|(c8&a9)|(c9&a10))&x11) | ((b0|(c0&b1)|(c1&b2)|(c2&b3)|(c3&b4)|(c4&b5)|(c5&b6)|(c6&b7)|(c7&b8)|(c8&b9)|(c9&b10))&y11) | (c10&y11);
char r12= ((a0|(c0&a1)|(c1&a2)|(c2&a3)|(c3&a4)|(c4&a5)|(c5&a6)|(c6&a7)|(c7&a8)|(c8&a9)|(c9&a10)|(c10&a11))&x12) | ((b0|(c0&b1)|(c1&b2)|(c2&b3)|(c3&b4)|(c4&b5)|(c5&b6)|(c6&b7)|(c7&b8)|(c8&b9)|(c9&b10)|(c10&b11))&y12) | (c11&y12);
char r13= ((a0|(c0&a1)|(c1&a2)|(c2&a3)|(c3&a4)|(c4&a5)|(c5&a6)|(c6&a7)|(c7&a8)|(c8&a9)|(c9&a10)|(c10&a11)|(c11&a12))&x13) | ((b0|(c0&b1)|(c1&b2)|(c2&b3)|(c3&b4)|(c4&b5)|(c5&b6)|(c6&b7)|(c7&b8)|(c8&b9)|(c9&b10)|(c10&b11)|(c11&b12))&y13) | (c12&y13);
char r14= ((a0|(c0&a1)|(c1&a2)|(c2&a3)|(c3&a4)|(c4&a5)|(c5&a6)|(c6&a7)|(c7&a8)|(c8&a9)|(c9&a10)|(c10&a11)|(c11&a12)|(c12&a13))&x14) | ((b0|(c0&b1)|(c1&b2)|(c2&b3)|(c3&b4)|(c4&b5)|(c5&b6)|(c6&b7)|(c7&b8)|(c8&b9)|(c9&b10)|(c10&b11)|(c11&b12)|(c12&b13))&y14) | (c13&y14);
char r15= ((a0|(c0&a1)|(c1&a2)|(c2&a3)|(c3&a4)|(c4&a5)|(c5&a6)|(c6&a7)|(c7&a8)|(c8&a9)|(c9&a10)|(c10&a11)|(c11&a12)|(c12&a13)|(c13&a14))&x15) | ((b0|(c0&b1)|(c1&b2)|(c2&b3)|(c3&b4)|(c4&b5)|(c5&b6)|(c6&b7)|(c7&b8)|(c8&b9)|(c9&b10)|(c10&b11)|(c11&b12)|(c12&b13)|(c13&b14))&y15) | (c14&y15);
return((uint16_t)((r0<<15)|(r1<<14)|(r2<<13)|(r3<<12)|(r4<<11)|(r5<<10)|(r6<<9)|(r7<<8)|(r8<<7)|(r9<<6)|(r10<<5)|(r11<<4)|(r12<<3)|(r13<<2)|(r14<<1)|r15));
}
int main() {
// your code goes here
int a=5;
int b=3;
cout << Max(a,b);
return 0;
}
قبلی مشکل داشت اما این چیزی بود که تونستم تا الان بسازم، مشکل داره هنوز اما اگه تا ی ساعت دیگه حل بشه میفرستم همینجا
#include
using namespace std;
uint16_t Max(uint16_t A,uint16_t B)
{
//Ba Arzesh Tarin
char x0 =(A>>15)&1;
char x1 =(A>>14)&1;
char x2 =(A>>13)&1;
char x3 =(A>>12)&1;
char x4 =(A>>11)&1;
char x5 =(A>>10)&1;
char x6 =(A>>9)&1;
char x7 =(A>>8)&1;
char x8 =(A>>7)&1;
char x9 =(A>>6)&1;
char x10=(A>>5)&1;
char x11=(A>>4)&1;
char x12=(A>>3)&1;
char x13=(A>>2)&1;
char x14=(A>>1)&1;
char x15=(A)&1;
char y0 =(B>>15)&1;
char y1 =(B>>14)&1;
char y2 =(B>>13)&1;
char y3 =(B>>12)&1;
char y4 =(B>>11)&1;
char y5 =(B>>10)&1;
char y6 =(B>>9)&1;
char y7 =(B>>8)&1;
char y8 =(B>>7)&1;
char y9 =(B>>6)&1;
char y10=(B>>5)&1;
char y11=(B>>4)&1;
char y12=(B>>3)&1;
char y13=(B>>2)&1;
char y14=(B>>1)&1;
char y15=(B)&1;
char r0= x0|y0;
char a0 = x0&(~y0);
char b0 = ~(x0)&y0;
char c0 = ~(a0^b0);
char a1 = x1&(~y1);
char b1 = (~x1)&y1;
char c1 = ~(a1^b1);
char a2 = x2&(~y2);
char b2= (~x2)&y2;
char c2 = ~(a2^b2);
char a3 = x3&(~y3);
char b3 = (~x3)&y3;
char c3 = ~(a3^b3);
char a4 = x4&(~y4);
char b4 = (~x4)&y4;
char c4 = ~(a4^b4);
char a5 = x5&(~y5);
char b5 = (~x5)&y5;
char c5 = ~(a5^b5);
char a6 = x6&(~y6);
char b6 = (~x6)&y6;
char c6 = ~(a6^b6);
char a7 = x7&(~y7);
char b7 = (~x7)&y7;
char c7 = ~(a7^b7);
char a8 = x8&(~y8);
char b8 = (~x8)&y8;
char c8 = ~(a8^b8);
char a9 = x9&(~y9);
char b9 = (~x9)&y9;
char c9 = ~(a9^b9);
char a10 = x10&(~y10);
char b10 = (~x10)&y10;
char c10 = ~(a10^b10);
char a11 = x11&(~y11);
char b11 = (~x11)&y11;
char c11 = ~(a11^b11);
char a12 = x12&(~y12);
char b12 = (~x12)&y12;
char c12 = ~(a12^b12);
char a13 = x13&(~y13);
char b13 = (~x13)&y13;
char c13 = ~(a13^b13);
char a14 = x14&(~y14);
char b14 = (~x14)&y14;
char c14 = ~(a14^b14);
char r1= (a0&x1) | (b0&y1) | (c0&y1);
char r2= ((a0|(c0&a1))&x2) | ((b0|(c0&b1))&y2) | (c1&y2);
char r3= ((a0|(c0&a1)|(c1&a2))&x3) | ((b0|(c0&b1)|(c1&b2))&y3) | (c2&y3);
char r4= ((a0|(c0&a1)|(c1&a2)|(c2&a3))&x4) | ((b0|(c0&b1)|(c1&b2)|(c2&b3))&y3) | (c3&y4);
char r5= ((a0|(c0&a1)|(c1&a2)|(c2&a3)|(c3&a4))&x5) | ((b0|(c0&b1)|(c1&b2)|(c2&b3)|(c3&b4))&y5) | (c4&y5);
char r6= ((a0|(c0&a1)|(c1&a2)|(c2&a3)|(c3&a4)|(c4&a5))&x6) | ((b0|(c0&b1)|(c1&b2)|(c2&b3)|(c3&b4)|(c4&b5))&y6) | (c5&y6);
char r7= ((a0|(c0&a1)|(c1&a2)|(c2&a3)|(c3&a4)|(c4&a5)|(c5&a6))&x7) | ((b0|(c0&b1)|(c1&b2)|(c2&b3)|(c3&b4)|(c4&b5)|(c5&b6))&y7) | (c6&y7);
char r8= ((a0|(c0&a1)|(c1&a2)|(c2&a3)|(c3&a4)|(c4&a5)|(c5&a6)|(c6&a7))&x8) | ((b0|(c0&b1)|(c1&b2)|(c2&b3)|(c3&b4)|(c4&b5)|(c5&b6)|(c6&b7))&y8) | (c7&y8);
char r9= ((a0|(c0&a1)|(c1&a2)|(c2&a3)|(c3&a4)|(c4&a5)|(c5&a6)|(c6&a7)|(c7&a8))&x9) | ((b0|(c0&b1)|(c1&b2)|(c2&b3)|(c3&b4)|(c4&b5)|(c5&b6)|(c6&b7)|(c7&b8))&y9) | (c8&y9);
char r10= ((a0|(c0&a1)|(c1&a2)|(c2&a3)|(c3&a4)|(c4&a5)|(c5&a6)|(c6&a7)|(c7&a8)|(c8&a9))&x10) | ((b0|(c0&b1)|(c1&b2)|(c2&b3)|(c3&b4)|(c4&b5)|(c5&b6)|(c6&b7)|(c7&b8)|(c8&b9))&y10) | (c9&y10);
char r11= ((a0|(c0&a1)|(c1&a2)|(c2&a3)|(c3&a4)|(c4&a5)|(c5&a6)|(c6&a7)|(c7&a8)|(c8&a9)|(c9&a10))&x11) | ((b0|(c0&b1)|(c1&b2)|(c2&b3)|(c3&b4)|(c4&b5)|(c5&b6)|(c6&b7)|(c7&b8)|(c8&b9)|(c9&b10))&y11) | (c10&y11);
char r12= ((a0|(c0&a1)|(c1&a2)|(c2&a3)|(c3&a4)|(c4&a5)|(c5&a6)|(c6&a7)|(c7&a8)|(c8&a9)|(c9&a10)|(c10&a11))&x12) | ((b0|(c0&b1)|(c1&b2)|(c2&b3)|(c3&b4)|(c4&b5)|(c5&b6)|(c6&b7)|(c7&b8)|(c8&b9)|(c9&b10)|(c10&b11))&y12) | (c11&y12);
char r13= ((a0|(c0&a1)|(c1&a2)|(c2&a3)|(c3&a4)|(c4&a5)|(c5&a6)|(c6&a7)|(c7&a8)|(c8&a9)|(c9&a10)|(c10&a11)|(c11&a12))&x13) | ((b0|(c0&b1)|(c1&b2)|(c2&b3)|(c3&b4)|(c4&b5)|(c5&b6)|(c6&b7)|(c7&b8)|(c8&b9)|(c9&b10)|(c10&b11)|(c11&b12))&y13) | (c12&y13);
char r14= ((a0|(c0&a1)|(c1&a2)|(c2&a3)|(c3&a4)|(c4&a5)|(c5&a6)|(c6&a7)|(c7&a8)|(c8&a9)|(c9&a10)|(c10&a11)|(c11&a12)|(c12&a13))&x14) | ((b0|(c0&b1)|(c1&b2)|(c2&b3)|(c3&b4)|(c4&b5)|(c5&b6)|(c6&b7)|(c7&b8)|(c8&b9)|(c9&b10)|(c10&b11)|(c11&b12)|(c12&b13))&y14) | (c13&y14);
char r15= ((a0|(c0&a1)|(c1&a2)|(c2&a3)|(c3&a4)|(c4&a5)|(c5&a6)|(c6&a7)|(c7&a8)|(c8&a9)|(c9&a10)|(c10&a11)|(c11&a12)|(c12&a13)|(c13&a14))&x15) | ((b0|(c0&b1)|(c1&b2)|(c2&b3)|(c3&b4)|(c4&b5)|(c5&b6)|(c6&b7)|(c7&b8)|(c8&b9)|(c9&b10)|(c10&b11)|(c11&b12)|(c12&b13)|(c13&b14))&y15) | (c14&y15);
return((uint16_t)((r0<<15)|(r1<<14)|(r2<<13)|(r3<<12)|(r4<<11)|(r5<<10)|(r6<<9)|(r7<<8)|(r8<<7)|(r9<<6)|(r10<<5)|(r11<<4)|(r12<<3)|(r13<<2)|(r14<<1)|r15));
}
int main() {
// your code goes here
int a=5;
int b=3;
cout << Max(a,b);
return 0;
}
خب بعد مدتها دوباره cpp زدم
تجربه خوبی بود
حیف تو تایم نرسید
ای کاش تایمش ی روز دیگه هم تمدید بشه
سلام
خواهش میکنم – دیگه واقعا طولانی میشد و احتمالا حجم جواب ها خیلی بیشتر میشد 🙂
ممنون که وقت گذاشتید
تلاش خوبی بود 🙂 اگر صحیح کار میکرد مشکلی نداشت قبول میکردیم ولی برای ورودی های زیر درست کار نکرد
A=1,B=0 Max=0
A=2,B=0 Max=0
A=2,B=1 Max=0
A=3,B=0 Max=1
A=3,B=1 Max=1
شما جواب رو بفرست یک ساعت مشکلی نداره 🙂
// (my second answer… this one is without using for loop)
uint16_t f1(uint16_t x){
uint16_t r = 0;
r |= x;
r |= x << 1;
r |= x << 2;
r |= x << 3;
r |= x << 4;
r |= x << 5;
r |= x << 6;
r |= x << 7;
r |= x << 8;
r |= x << 9;
r |= x << 10;
r |= x << 11;
r |= x << 12;
r |= x << 13;
r |= x << 14;
r |= x <> i) & 1;
}
uint16_t f3(uint16_t x, uint16_t i){
return ((x >> i) & 1) ^ 1;
}
uint16_t f(uint16_t x, uint16_t y, uint16_t a, uint16_t b, uint16_t i){
uint16_t d = 0xFFFF;
a |= f1(f2(x, i) & f3(y, i)) & (d ^ b);
return a;
}
uint16_t big(uint16_t x, uint16_t y) {
uint16_t b = 0;
uint16_t a = 0;
a |= f(x, y, a, b, 15);
b |= f(y, x, b, a, 15);
a |= f(x, y, a, b, 14);
b |= f(y, x, b, a, 14);
a |= f(x, y, a, b, 13);
b |= f(y, x, b, a, 13);
a |= f(x, y, a, b, 12);
b |= f(y, x, b, a, 12);
a |= f(x, y, a, b, 11);
b |= f(y, x, b, a, 11);
a |= f(x, y, a, b, 10);
b |= f(y, x, b, a, 10);
a |= f(x, y, a, b, 9);
b |= f(y, x, b, a, 9);
a |= f(x, y, a, b, 8);
b |= f(y, x, b, a, 8);
a |= f(x, y, a, b, 7);
b |= f(y, x, b, a, 7);
a |= f(x, y, a, b, 6);
b |= f(y, x, b, a, 6);
a |= f(x, y, a, b, 5);
b |= f(y, x, b, a, 5);
a |= f(x, y, a, b, 4);
b |= f(y, x, b, a, 4);
a |= f(x, y, a, b, 3);
b |= f(y, x, b, a, 3);
a |= f(x, y, a, b, 2);
b |= f(y, x, b, a, 2);
a |= f(x, y, a, b, 1);
b |= f(y, x, b, a, 1);
a |= f(x, y, a, b, 0);
b |= f(y, x, b, a, 0);
a |= ~b;
return (x & a) ^ (y & b);
}
کدی که با for نوشتم در واقع c++ هست پس این کد رو فرستادم که کاملا زبان C هست
همون کد اول هم اوکی هست 🙂
سلام. چطور میتونم به آی دی شخصیتون پیام بدم؟
یه مسئله هست باید خصوصی بگم..
آی دی تلگرام و اینستاگرامم : ×
پیام بگذارید از فرم تماس با ما
🙂
قابل بررسی نیست کد
لطفا توی سایت https://pastecode.xyz/ بذارید و آدرسش رو انجا کامنت کنید.
#include “iostream”
using namespace std;
uint16_t range1[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
uint16_t range2[16] = {15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
// if x = 0 returns 0
// if x = 1 returns 0xFFF
uint16_t f1(uint16_t x){
uint16_t r = 0;
for(auto i: range1){
r |= x <> i) & 1;
}
// returns complement of ith bit of x
uint16_t f3(uint16_t x, uint16_t i){
return ((x >> i) & 1) ^ 1;
}
// returns 0xFFFF if ith bit of x is 1 and ith bit of y is 0
// returns 0 ow
uint16_t f(uint16_t x, uint16_t y, uint16_t a, uint16_t b, uint16_t i){
uint16_t d = 0xFFFF;
a |= f1(f2(x, i) & f3(y, i)) & (d ^ b);
return a;
}
// returns the maximum number
uint16_t maximum(uint16_t x, uint16_t y) {
uint16_t b = 0;
uint16_t a = 0;
// if x > y then set a = 0xFFFF and b = 0
// if y > x then set b = 0xFFFF and a = 0
for(auto i: range2){
a |= f(x, y, a, b, i);
b |= f(y, x, b, a, i);
}
a |= ~b; // if x = y return x
return (x & a) ^ (y & b);
}
int main(){
cout << maximum(81, 18) << endl;
}
الان تابع f2 شما تو این کد نیست !
فکر میکنم موقع کامنت گذاشتن حذف شده باشه – لطفا مجددا کدتون رو توی https://pastecode.xyz/ بذارید و لینکش رو ایجا قرار بدید.
متشکرم
سیسوگ من هر کار کردم نتونستم کد کامل رو در نظرات نمایش بدم. اما خب لینک کد در کامپایلر آنلاین هست.
اوکیه – کار خوبی کردید – بررسی شد و درست کار میکرد.
نویسنده: میرزاپور 29/12/98
توضیحاتی در مورد برنامه نوشته شده برای پیدا کردن ماکسیمم دو عدد بدون عبارات شرطی و محاسباتی
در این برنامه از فرمول موجود در کتاب های مبانی دیجیتال برای محاسبه استفاده شده است. مثلا برای اعداد 4 بیتی فرمول به صورت زیرمی باشد.
(A>B)=A_3.B_3^’+x_3.A_2.B_2^’+x_3.x_2.A_1.B_1^’+x_3.x_2.x_1.A_0.B_0^’ (1)
خروجی فرمول بالا یک بیت می باشد که در صورتی که A>B مقدار آن یک کی شود. متغییر x نیز حاصل XNOR کردن اعداد A و B می باشد.
x_i=A_i.B_i+A_i^’.B_i^’ (2)
برای پیاده سازی فرمول بالا با استفاده از زبان C رابطه 1 را به صورت زیر بازنویسی می کنیم.
Tmp=A.B^’ | Y_(3 ) | Y_2 | Y_1 (3)
Y_3=(1x_3 x_3 x_3 )
Y_2=(11x_2 x_2 )
Y_1=(111x_1 )
در این مرحله باید بتوانیم Yi ها را بدست بیاوریم. برای اینکار تابع CCi مقادیر زیر را بدست می آورد
〖CC〗_3=(x_3 x_3 x_3 x_3)
〖CC〗_2=(x_2 x_2 x_2 x_2)
〖CC〗_1=(x_1 x_1 x_1 x_1)
سپس تابع Yi مقادیرY1 , Y2 , Y3 را به این صورت حساب می کند که ابتدا در متغییر D را مقدار دهی می کند مثلا برای محاسبه Y1 متغییر D=(1000) را قرار می دهد و سپس آن را با CC1 ضرب(AND منطقی) می کند و Y1 بدست می آید.
لطفا پاسخ نوشته شده برای کدتون رو بررسی کنید
متشکرم
#include
#include
#include
#include
unsigned int CCi(unsigned int a, unsigned int b, unsigned char i);
unsigned int Yi(unsigned int a, unsigned int b, unsigned char i);
unsigned int retMax(unsigned int A, unsigned int B);
int main()
{
unsigned int A,B,j;
for(j=0;j<100;j++)
{
A=rand();
B=rand();
printf("A=%5d, B=%5d, Max is=%5d\n",A,B,retMax(A,B));
}
return 0;
}
unsigned int CCi(unsigned int a, unsigned int b, unsigned char i)
{
unsigned int xNor;
unsigned int C,CCi;
xNor=~(a^b);
C= (xNor&(1<>i;
CCi=(C<<15)|(C<<14)|(C<<13)|(C<<12)|(C<<11)|(C<<10)|(C<<9)|(C<<8)|(C<<7)|(C<<6)|(C<<5)|(C<<4)|(C<<3)|(C<<2)|(C<<1)| C;
return CCi;
}
unsigned int Yi(unsigned int a, unsigned int b, unsigned char i)
{
unsigned int D,Y;
D=(0xffff<<i);
Y=D|CCi(a,b,i);
return Y;
}
unsigned int retMax(unsigned int A, unsigned int B)
{
unsigned int T;
bool bit;
T=(A&(~B))&Yi(A,B,15)&Yi(A,B,14)&Yi(A,B,13)&Yi(A,B,12)&Yi(A,B,11)&Yi(A,B,10)&Yi(A,B,9)&Yi(A,B,8)&Yi(A,B,7)&Yi(A,B,6)&Yi(A,B,5)&Yi(A,B,4)&Yi(A,B,3)&Yi(A,B,2)&Yi(A,B,1);
bit=(bool)T;
T=(bit<<15)|(bit<<14)|(bit<<13)|(bit<<12)|(bit<<11)|(bit<<10)|(bit<<9)|(bit<<8)|(bit<<7)|(bit<<6)|(bit<<5)|(bit<<4)|(bit<<3)|(bit<<2)|(bit<<1)| bit;
return (T&A) | (~T)&B;
}
سلام من کد شما رو (https://pastecode.xyz/view/68965d6a) با ورودی های زیر چک کردم که مشکل داشت
A=1,B=0 Max=0
A=2,B=0 Max=0
A=2,B=1 Max=1
A=3,B=0 Max=0
A=3,B=1 Max=1
سلام. به نظرم در تست کد بنده اشتباهی پیش آمده. در تست کردن تابع از تابعی که خودتون اضافه کردین استفاده شده که بدنه تابع خالی است و اصلا از تابی که من نوشتم استفاده نشده است. ممنون میشم یک بار دیگر پک بفرمایید
آیا تابع zMax در خط 41 از کد https://pastecode.xyz/view/68965d6a تابع شما نیست ؟
فکر میکنم اونچه شما دیدید خط 52 است که کامنت است!
کد را در سایت کپی کردم و آدرس خدمتتون ارسال میکنم.لطفا بررسی بفرمایید
https://pastecode.xyz/view/9929a549
سلام سال نو پیشاپیش مبارک
سیسوگ خیلی ممنونم از این چالش باحال.
من مطمئن هستم افرادی که با مبحث مدارهای منطقی و معماری کامپیوتر آشنایی دارند هم جواب مختصر و بهینه تری برای ارائه دارند و هم اینکه شاید توانایی بهتری برای توضیح الگوریتم داشته باشند. اما با توجه به اینکه کد من از نظر الگوریتمی درست هست و چند بار تستش کردم من هم الگوریتم و توضیحش رو به اشتراک میزارم.
توضیح الگوریتم:
ورودی مسئله : دوعدد 16 بیتی a و b
خروجی : بزرگترین عدد بین a و b
خب همونجور که واضح هست با توجه به اینکه در صورت سوال ما محدود به استفاده از عملگرهای منطقی شدیم بنابراین باید برای مقایسه دو عدد bit به bit عمل کنیم. در اینجا فرض میگیریم که کامپیوتر این دو عدد 16 بیتی را به روش little endian ذخیره کرده و با ارزش ترین bit در آخرین خانه حافظه یا همان بیت 16 ام ذخیره شده. (برای باارزش ترین بیت n=0 برای کم ارزش ترین بیت n=15 در نظر میگیریم، کد زدنش راحت تره)
خب واضح هست که اگر قرار باشه هر بیت را با بیت مقابلش مقایسه کنیم و با توجه به اینکه مقدار هر بیت یا 0 هست و یا 1 برای پیدا کردن بزرگترین بیت میتونیم a و b را با هم or کنیم یعنی a|b. اما خب مشخصه که این کار درست نیست و ما با اینکار به اجتماع دو عدد میرسیم و نه بزرگترین عدد.
پس بنابراین ما باید در عبارت a|b تغییراتی ایجاد کنیم تا تاثیر مقایسه bitهای با ارزش تر در bit های کم ارزش تر لحاظ بشند.
بنابراین برای مقایسه این دو عدد از بیت با ارزش بالاتر شروع میکنیم و تا آخرین بیت پیش میریم. کاملا واضح که اگر از مقایسه بیت های باارزش تر به نتیجه برسیم دیگه نیازی به مقایسه بیت های کم ارزش تر نداریم اما با توجه به اینکه اجازه استفاده از عبارات شرطی رو نداریم باید الگوریتم رو جوری بنویسیم تا اولویت با مقایسه بیت های باارزش تر باشد.
پس الگوریتم رو برای مقایسه هر دو بیت با توجه به تاثیر مقایسه بیت های قبلی به شکل زیر تغییر میدیم:
digit(n) = ((a&ca[n]) | (b&cb[n])) & (1<< (15-n))
عبارات ca و cb را من اسمش رو گذاشتم ضریب تاثیر بیت بالاتر و در حقیقت نشانگر این هستند که آیا از مقایسه بیت با ارزش تر قبلی عدد بزرگتر پیدا شده است یا نه. به عنوان مثال اگر در مقایسه یا مقایسه های قبلی مشخص شده باشه که عدد a بزرگتر هست بنابراین ca یک میشه و cb صفر و در نتیجه فقط تاثیر a در اون بیت ظاهر میشه. در آخر نتیجه رو & (1<< (15-n)) میکنیم تا فقط تاثیر این بیت در در عدد 16 بیتی دخیره بشه.
خب حالا ca و cb رو چجوری پیدا کنیم؟
فرض ما اینه که ca و cb برای هر بیت تاثیرگذار یک هستند و برای هر بیت بی تاثیر صفر. پس یعنی در مقایسه با ارزش ترین بیت یا بیت 16 ام این دو ضریب یک هستند(چرا؟). چون در اینجا از مقایسه a|b میشه بیت بزرگتر رو پیدا کرد.
ca[0] = 1<<15
و
cb[0] = 1<>1)
و
cb[n] =(( ((ca[n-1] ^ cb[n-1]) | (b | (~(a^b))) ) & cb[n-1]) >>1)
خب واقعا توضیحش سخته، ببینید ما میخوایم از مقایسه بیت فعلی (بیت n) ببینیم که که ضریب تاثیر هر عدد چه مقداری هست. و کارکرد عبارات (a | (~(a^b))) و (b | (~(a^b))) برای همین هست. اگر نتیجه منطقی این عبارت رو چک کنید میبینید که نتایج خروجی برای عدد a و b مقادیر [1,1] , [0,1] و [1,0] میشه یعنی همون مقادیری که برای ca و cb مجاز میدونیم.
اما برای تاثیر ضرایب بیت قبلی در این عبارت چکار کنیم. کاملا واضحه که اگر در مقایسه قبلی عدد بزرگتر پیدا شده باشه باید در نتیجه ضرایب ca و cb تغییری ایجاد نشه اما اگر در مقایسه فعلی عدد بزرگتر پیدا بشه باید ضرایب ca و cb به [1,0] یا [1,1] تغییر پیدا کنه و گر نه همون مقادیر قبلی که میتونه هر کدام از مقادیر [1,1] , [0,1] و [1,0] باشه میمونه.
برای رسیدن به همچین نتیجه ای (ca[n-1] ^ cb[n-1]) را با ضرایب بدست آمده فعلی(عبارت قبلی) or میکنیم(چرا؟) خب اگر ضرایب قبلی [1,1] باشند باید این اجازه رو به ضرایب بدست آمده از بیت فعلی بدیم تا خودی نشون بدن. 🙂
حالا چرا آخر سر کل عبارت رو با & ca[n-1] (وcb) کردیم، چونکه فرض کنید ضرایب تاثیر قبلی [1,0] بوده و نتیجه ضرایب بدست اومده از بیت های فعلی [0,1 ] باشه کاملا واضح هست اگر بخوایم این دو تا مقدار را فقط با هم or کنیم نتیجه [1,1] میشه که خب حالت مجازی نیست و باید نتیجه همون ضریب تاثیر قبلی [1,0] بمونه. بنابراین برای اصلاح الگوریتم این عبارت رو بهش اضافه کردیم.
و در آخر چون قرار این فرمول برای بیت از n=1 تا 15 استفاده بشه بنابراین در هر مرحله یدونه به راست شیفت پیدا کرده (از با ارزش به کم ارزش).
در آخر داستان با بعد از محاسبه بیت به بیت عدد بزرگتر میشه or تمام دیجیت ها : (n=0 بیت با ارزش تر )
max_a_b = digit(0) | digit(1) | … | digit(14) | digit(15)
با تشکر از حسن توجهتون. خوبه که به این نکته اشاره کنم که چون این الگوریتم با محاسبه ارزش های بیتی روی ورق و پیشنهاد عبارات منطقی بر اساس شروط منطقی نوشته شده ممکنه توضیح و درکش کمی سخت و عجیب باشه و مطمئنن برای یک فرد حرفه ای عبارات منطقی استفاده شده قابلیت ساده سازی بیشتری دارند. بهرحال هدف و توان من بهینگی کد نبوده و بیشتر هدفم نوشتن الگوریتم مناسب روی ورق بوده.
همچنین اول تلاش کردم که این کد رو بصورت بازگشتی بنویسم و بعد تلاش کردم که کد رو با استفاده از مقادیر boolean بنویسم تا شکل کد هم بیتی باشه اما خب مهارت لازم رو نداشتم و کامپایلر آنلاینی که استفاده کردم محدودیت داشت. بنابراین با توجه به ددلاین این چالش با همین توان دست و پاشکسته کدی نوشتم که شاید از نظر خیلی ها معمولی باشه. اما خب در الگوریتم ایرادی نیست و جواب درست میده.
لینک کد در کامپایلر آنلاین : https://onlinegdb.com/r10_AM-8U
کد اصلی و تست شده:
سلام ممنون
هم منطق برنامه درست و هم به خوبی کار میکنه 🙂
کد تست : https://pastecode.xyz/view/716db13b
سلام
من چون چند وقتی برنامه ننوشته ام شاید نتونم درست سینتکس ها را بنویسم ولی میتونم منطق خودم رو بنویسم:
در یک حلقه فور ۱۶ تایی از بیت کم اهمیت تر شروع میکنیم به پر اهمیت ترین میرویم و هر بار کل عدد بزرگتر را با یک حلقه فور ۱۶ تایی در متغیر خروجی میگذاریم (دو بیت مورد مقایسه برابر نباشند عدد بزرگتر تعیین میشود)
فرض کنید که برای تعیین بزرگتر بودن عدد اول یا دوم از متغیر تک بیتی آ استفاده کنیم(اگر یک بود عدد اول و اگر صفر بود عدد دوم بزرگ تر است)
برای درست کردن شرط هم از ایکس اور استفاده میکنیم: (ایکس اور آ با یک * عدد اول)+(ایکس اور آ با صفر * عدد دوم)
// این به این معنی است که اگر آ یک بود قسمت دوم(به لطف اند(یا *)) صفر میشود و اگر آ صفر بود قسمت اول صفر میشود.
حال باید آ را مقدار دهی کنیم تا از ان در حلقه دوم یا داخلی (قرار بود به وسیله شرط توضیح داده شده کل عدد اول یا دوم را در متغیر خروجی بریزد):
آ برابر میشود با: (ایکس اور عدد اول با ۱) اور با (ایکس اور عدد دوم با ۰) // (**اینجا اعداد در بیت مذکور که حلقه اول یا خارجی مشخص کرده است هستند**)
فقط نکته مهم این است که باید آ اولش یک مقداری داشته باشد.
در مورد حالات دیگر یعنی:
اگر بیت ها برابر باشند آ حالت قبلی خودش را حفظ کرده پس مشکلی نیست.
اگر عدد ها مساوی باشند آ مقدار دهی اولیه شده پس باز یکی از اعداد به متغیر خروجی میرود و مهم نیست چون برابره.
و نکته اخر این که برای تعیین آ همان قسمت اول کافی بود ولی برای خواناتر شدن هر دو قسمت را نوشتم.
سلام و درود
ممنون برای این که در چالش شرکت کردید 🙂 توضیحاتتون درسته ولی به دلیل این که کد ارائه نکردید امکان بررسی توسط ما نیست
چرا که همونطور که میدونید نحوه پیاده سازی هم مهمه
واقعا مغزم پوکید جناب سیسوگ یا شاید zeus
اصل تابع این هست که با گیت های منطقی نوشتم
max=((A+b)+(A-b))/2
کد رو اینجا نوشتم و تست گرفتم که اجرا کنید باید نشون بده!!
https://onlinegdb.com/S1mHvWZ8I
#include
using namespace std;
void sum_one_bit (bool a, bool b, bool c, bool & sum, bool & carry);
long sum_int (int a, int b);
long subtraction_int (int a, int b);
int biger( int g,int f);
int
main ()
{
//cout<> 1;
cout<< "a="<<g<<" b="<<f<<" max="<<max<<"\r\n";
return max;
}
//———————————————————-
//—————————————————————
//—————————————————————
long
subtraction_int (int a, int b)
{
bool b0 = (b & 0x01);
bool b1 = (b & 0x02);
bool b2 = (b & 0x04);
bool b3 = (b & 0x08);
bool b4 = (b & 0x10);
bool b5 = (b & 0x20);
bool b6 = (b & 0x40);
bool b7 = (b & 0x80);
bool b8 = (b & 0x100);
bool b9 = (b & 0x200);
bool b10 = (b & 0x400);
bool b11 = (b & 0x800);
bool b12 = (b & 0x1000);
bool b13 = (b & 0x2000);
bool b14 = (b & 0x4000);
bool b15 = (b & 0x8000);
b0 = ~b0 & 0x01;
b1 = ~b1 & 0x01;
b2 = ~b2 & 0x01;
b3 = ~b3 & 0x01;
b4 = ~b4 & 0x01;
b5 = ~b5 & 0x01;
b6 = ~b6 & 0x01;
b7 = ~b7 & 0x01;
b8 = ~b8 & 0x01;
b9 = ~b9 & 0x01;
b10 = ~b10 & 0x01;
b11 = ~b11 & 0x01;
b12 = ~b12 & 0x01;
b13 = ~b13 & 0x01;
b14 = ~b14 & 0x01;
b15 = ~b15 & 0x01;
int bb =
b15 << 15 |
b14 << 14 |
b13 << 13 |
b12 << 12 |
b11 << 11 |
b10 << 10 |
b9 << 9 |
b8 << 8 |
b7 << 7 |
b6 << 6 | b5 << 5 | b4 << 4 | b3 << 3 | b2 << 2 | b1 << 1 | b0 << 0;
long bbb = sum_int (a, bb);
return (sum_int (bbb, 1));
}
//———————————————————-
//—————————————————————
//—————————————————————
long
sum_int (int a, int b)
{
bool a0 = a & 0x01;
bool a1 = a & 0x02;
bool a2 = a & 0x04;
bool a3 = a & 0x08;
bool a4 = a & 0x10;
bool a5 = a & 0x20;
bool a6 = a & 0x40;
bool a7 = a & 0x80;
bool a8 = a & 0x100;
bool a9 = a & 0x200;
bool a10 = a & 0x400;
bool a11 = a & 0x800;
bool a12 = a & 0x1000;
bool a13 = a & 0x2000;
bool a14 = a & 0x4000;
bool a15 = a & 0x8000;
bool b0 = b & 0x01;
bool b1 = b & 0x02;
bool b2 = b & 0x04;
bool b3 = b & 0x08;
bool b4 = b & 0x10;
bool b5 = b & 0x20;
bool b6 = b & 0x40;
bool b7 = b & 0x80;
bool b8 = b & 0x100;
bool b9 = b & 0x200;
bool b10 = b & 0x400;
bool b11 = b & 0x800;
bool b12 = b & 0x1000;
bool b13 = b & 0x2000;
bool b14 = b & 0x4000;
bool b15 = b & 0x8000;
bool carry = 0;
bool sum;
bool s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15,
s16;
sum_one_bit (a0, b0, carry, sum, carry);
s0 = sum;
sum_one_bit (a1, b1, carry, sum, carry);
s1 = sum;
sum_one_bit (a2, b2, carry, sum, carry);
s2 = sum;
sum_one_bit (a3, b3, carry, sum, carry);
s3 = sum;
sum_one_bit (a4, b4, carry, sum, carry);
s4 = sum;
sum_one_bit (a5, b5, carry, sum, carry);
s5 = sum;
sum_one_bit (a6, b6, carry, sum, carry);
s6 = sum;
sum_one_bit (a7, b7, carry, sum, carry);
s7 = sum;
sum_one_bit (a8, b8, carry, sum, carry);
s8 = sum;
sum_one_bit (a9, b9, carry, sum, carry);
s9 = sum;
sum_one_bit (a10, b10, carry, sum, carry);
s10 = sum;
sum_one_bit (a11, b11, carry, sum, carry);
s11 = sum;
sum_one_bit (a12, b12, carry, sum, carry);
s12 = sum;
sum_one_bit (a13, b13, carry, sum, carry);
s13 = sum;
sum_one_bit (a14, b14, carry, sum, carry);
s14 = sum;
sum_one_bit (a15, b15, carry, sum, carry);
s15 = sum;
s16 = carry;
return s16 << 16 |
s15 << 15 |
s14 << 14 |
s13 << 13 |
s12 << 12 |
s11 << 11 |
s10 << 10 |
s9 << 9 |
s8 << 8 |
s7 << 7 |
s6 << 6 | s5 << 5 | s4 << 4 | s3 << 3 | s2 << 2 | s1 << 1 | s0 << 0;
}
//—————————————————————
//—————————————————————
//—————————————————————
void
sum_one_bit (bool a, bool b, bool c, bool & sum, bool & carry)
{
bool x = a ^ b;
sum = x ^ c;
carry = (x & c) | (a & b);
}
سلام دوست عزیز
منطق درستی رو پیش رفتید ولی یه سری نکات رو ندیدید مثلا شما همین برنامه رو برای ورودی های زیر چک کنید
A=0,B=2
A=0,B=3
A=0,B=4
A=0,B=5
+ خوبی چالش همینه دیگه آدم ذهنش درگیر مساله میشه 🙂
با سلام و عرض وقت بخیر
برای حل سوال با توجه به شرط هایی که گذاشته شده بود، من از یک مقایسه کننده 2 بیتی استفاده کردم. اما چون ما به مقایسه دو عدد 16 بیتی نیاز داریم، خروجی هر طبقه با آرایش خاصی به طبقه بعد وصل میشه. طرز کارش هم به این صورته که طبقه اول، دو بیت اول از اعداد دریافتی رو با هم مقایسه میکنه و سه خروجی بزرگ تر، کوچک تر ومساوی رو میده. خروجی بزرگ تر هر طبقه به ورودی کم ارزش عدد اوله طبقه بعدی وصل میشه و خروجی کوچک تر هم به ورودی کم ارزش عدد دومه طبقه بعد وصل میشه و این کار برای تمامی بیت های دو عدد تکرار میشه، در نهایت در طبقه آخر مثل هر طبقه، 3 خروجی بزرگتر، کوچکتر و مساوی رو داریم. حالا برای برگشت عدد بزرگتر باید از این علامت های خروجی استفاده کنیم. در نهایت با یک تابع هر کدام از علامت های خروجی، در تمامی بیت های یه متغیر 16 بیتی کپی میشه و با عملیات & و | بیتی عدد بزرگتر مشخص میشه، اگر دو عدد هم مساوی باشن باز هم یکی برگشت داده میشه و سپس عدد بزرگتر به خروجی ارسال میشه.
این هم کد، البته بهتر بود تو فایل attach بشه.
#define _CRT_SECURE_NO_WARNINGS //if using Visual Studio else remove
#include
#include
#include
/*
…………………
| 2BIT |
A0->| COMPARATOR A>B|->
A1->| A=B|->
B1->| A
B0->| |
———————
*/
typedef union
{
uint16_t number;
struct
{
uint16_t bit0 : 1;
uint16_t bit1 : 1;
uint16_t bit2 : 1;
uint16_t bit3 : 1;
uint16_t bit4 : 1;
uint16_t bit5 : 1;
uint16_t bit6 : 1;
uint16_t bit7 : 1;
uint16_t bit8 : 1;
uint16_t bit9 : 1;
uint16_t bit10 : 1;
uint16_t bit11 : 1;
uint16_t bit12 : 1;
uint16_t bit13 : 1;
uint16_t bit14 : 1;
uint16_t bit15 : 1;
}bits;
struct
{
uint16_t grt : 1;
uint16_t equ : 1;
uint16_t les : 1;
uint16_t res : 13;
}output;
}uint16_parser_t;
uint16_t comp2bit(bool num1_bit0, bool num1_bit1, bool num2_bit0, bool num2_bit1);
uint16_t set_bit(bool bit_mask);
uint16_t greater(uint16_t num1, uint16_t num2);
int main(void)
{
uint16_t num1 = 0, num2 = 0;
while (true)
{
printf(“Please enter num1 : “);
scanf(“%d”, &num1);
printf(“Please enter num2 : “);
scanf(“%d”, &num2);
printf(“Greater number between {%d,%d} = %d\n\n\n”, num1, num2, greater(num1, num2));
}
return 0;
}
uint16_t comp2bit(bool num1_bit0, bool num1_bit1, bool num2_bit0, bool num2_bit1)
{
uint16_parser_t temp;
temp.number = 0;
temp.output.grt = ((num1_bit1) & (~num2_bit1)) | ((~num2_bit0)&((num1_bit0&(~num2_bit1)) | (num1_bit0 & num1_bit1)));
temp.output.les = ((~num1_bit1)&num2_bit1) | (num2_bit0 & num2_bit1 & (~num1_bit0)) | ((~num1_bit0)&(~num1_bit1)&num2_bit0);
temp.output.equ = (~(num1_bit0 ^ num2_bit0)) & (~(num1_bit1 ^ num2_bit1));
return (uint16_t)(temp.number & (0x0007));
}
uint16_t set_bit(bool bit_mask)
{
uint16_t temp = 0;
temp |= (bit_mask << 0);
temp |= (bit_mask << 1);
temp |= (bit_mask << 2);
temp |= (bit_mask << 3);
temp |= (bit_mask << 4);
temp |= (bit_mask << 5);
temp |= (bit_mask << 6);
temp |= (bit_mask << 7);
temp |= (bit_mask << 8);
temp |= (bit_mask << 9);
temp |= (bit_mask << 10);
temp |= (bit_mask << 11);
temp |= (bit_mask << 12);
temp |= (bit_mask << 13);
temp |= (bit_mask << 14);
temp |= (bit_mask << 15);
return temp;
}
uint16_t greater(uint16_t num1, uint16_t num2)
{
uint16_parser_t result, num1_temp, num2_temp;
result.number = 0;
num1_temp.number = num1;
num2_temp.number = num2;
result.number = comp2bit((bool)num1_temp.bits.bit0, (bool)num1_temp.bits.bit1, (bool)num2_temp.bits.bit0, (bool)num2_temp.bits.bit1);
result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit2, (bool)result.output.les, (bool)num2_temp.bits.bit2);
result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit3, (bool)result.output.les, (bool)num2_temp.bits.bit3);
result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit4, (bool)result.output.les, (bool)num2_temp.bits.bit4);
result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit5, (bool)result.output.les, (bool)num2_temp.bits.bit5);
result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit6, (bool)result.output.les, (bool)num2_temp.bits.bit6);
result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit7, (bool)result.output.les, (bool)num2_temp.bits.bit7);
result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit8, (bool)result.output.les, (bool)num2_temp.bits.bit8);
result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit9, (bool)result.output.les, (bool)num2_temp.bits.bit9);
result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit10, (bool)result.output.les, (bool)num2_temp.bits.bit10);
result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit11, (bool)result.output.les, (bool)num2_temp.bits.bit11);
result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit12, (bool)result.output.les, (bool)num2_temp.bits.bit12);
result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit13, (bool)result.output.les, (bool)num2_temp.bits.bit13);
result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit14, (bool)result.output.les, (bool)num2_temp.bits.bit14);
result.number = comp2bit((bool)result.output.grt, (bool)num1_temp.bits.bit15, (bool)result.output.les, (bool)num2_temp.bits.bit15);
result.number = (set_bit((bool)result.output.grt) & num1) | (set_bit((bool)result.output.les) & num2) | (set_bit((bool)result.output.equ) & num1);
return (uint16_t)result.number;
}
سلام – برنامه شما هم منطق درستی رو پیش رفته و به خوبی هم کار میکنه
کد تست شما : https://pastecode.xyz/view/d6688369
سلام خسته نباشین.من دوبار دیگم فرستادم اما متوجه شدم که دوتای قبلی مشکل دارن.
https://pastecode.xyz/view/5b4918c3 این کد نهاییه و مشکلی نداره
کد شما بررسی شد و به خوبی کار کرد.
کد تست : https://pastecode.xyz/view/b36401fb
خیلی ممنون بابت وقتی که گذاشتین??
سلام
کلا قبلی ها رو نادیده بگیرید. همون کاری که گفتید رو انجام دادم.
کد: https://pastecode.xyz/view/75f51bb8
لینک توضیح: https://pastecode.xyz/view/77df7471
برای محکم کاری 🙂
توضیح:
تابع sub یک تابع تفریق 32 بیتی است که y را از x کم می کند و با اپراتور های بیتی پیاده سازی شده. دلیل ۳۲ بیت بودن این تابع این است که حد اکثر ورودی تابع max عدد 65535 است و این عدد در یک متغیر 16 بیتی علامت دار جا نمی گیری پس ورودی را تا ۳۲ بیت علامت دار افزایش دادم.
تابع max هم عدد بزرگ تری که به این تابع پاس شده را برمیگرداند.
روش: اگر حاصل xor دو عدد را با اولین عدد xor کنیم دومین عدد بدست می آید و برعکس
قسمت اول: این تابع به صورتی کار می کند که اگر x > y بود، x را با عددی xor می کند که حاصل همان x باشد که آن عدد 0 است و هر گاه x y و -1 در شرایطی که x y باشد حاصل x – y حتما مثبت خواهد بود و اگر آن را یکی کم تر از طول متغیر (اینجا 31) به راست شیفت بدهیم حاصل 0 خواهد شد. اگر x > (31))
با سر هم کردن این سه قسمت خواهیم داشت:
return x ^ ( (x ^ y) & (uint16_t)(sub(x, y) >> (31)) )
بسیار عالی بررسی شد به خوبی کار میکرد
کد تست : https://pastecode.xyz/view/f053ec52
با سلام به دلیل زیاد بودن توضیحات آن ها درون یک فایل pdf همراه برنامه درون دو محیط codeblock و atmel studio قرار دادم در صورت وجود مشکل لطفا اطلاع دهید.
با تشکر
لینک آیینه:
http://s1.uupload.ir/files/alitoos123/ali-torabi.zip
با سلام لطفا برنامه من را هم برسی کنید
سلام دوست عزیز
برنامه شما هم به خوبی کامپایل شد و هم به خوبی کار کرد 🙂
توضیحات شما هم کامل بود واقعا 🙂
تست کد شما : https://pastecode.xyz/view/ea9069a2
با عرض سلام و خسته نباشید https://pastecode.xyz/view/84222c44
توضیحم:
توضیح:
تابع sub یک تابع تفریق 32 بیتی است که y را از x کم می کند. دلیل ۳۲ بیت بودن این تابع این است که حد اکثر ورودی تابع max عدد 65535 است و این عدد در یک متغیر 16 بیتی علامت دار جا نمی گیری پس ورودی را تا ۳۲ بیت علامت دار افزایش دادم.
تابع max هم عدد بزرگ تری که به این تابع پاس شده را برمیگرداند.
روش: اگر حاصل xor دو عدد را با اولین عدد xor کنیم دومین عدد بدست می آید و برعکس
قسمت اول: این تابع به صورتی کار می کند که اگر x > y بود، x را با عددی xor می کند که حاصل همان x باشد که آن عدد 0 است و هر گاه x y و -1 در شرایطی که x y باشد حاصل x – y حتما مثبت خواهد بود و اگر آن را یکی کم تر از طول متغیر (اینجا 31) به راست شیفت بدهیم حاصل 0 خواهد شد. اگر x > (31))
با سر هم کردن این سه قسمت خواهیم داشت:
return x ^ ( (x ^ y) & (uint16_t)(sub(x, y) >> (31)) )
سلام
توی هر دو مورد کد مشکل داره و کامپایل نمیشه – مثلا متغییر a کجا تعریف شده ؟
برای ارسال کد از سایت https://pastecode.xyz/ استفاده کنید
کد ناقص ارسال میشه نمی دونم چرا!
سلام برید توی آدرس https://pastecode.xyz/ و کد صحیح رو قرار بدید و لینکش رو کامنت کنید.
دفعه قبل جواب کامل نیومد(یا شاید من نمی تونم اینجا کامل ببینم)
کدم:
#include
#include
int32_t sub(int32_t x, int32_t y)
{
int32_t borrow;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow <> (31));
uint16_t b = (x ^ y) & a;
uint16_t result = x ^ b;*/
return x ^ ( (x ^ y) & (uint16_t)(sub(x, y) >> (31)) );
}
int main()
{
printf(“larger number is %d \n”,max(65535,1));
return 0;
}
#include
#include
int32_t sub(int32_t x, int32_t y)
{
int32_t borrow;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow << 1;
borrow = (~x) & y; x = x ^ y; y = borrow <> (31));
uint16_t b = (x ^ y) & a;
uint16_t result = x ^ b;*/
return x ^ ( (x ^ y) & (uint16_t)(sub(x, y) >> (31)) );
}
int main()
{
printf(“larger number is %d \n”,max(65535,1));
return 0;
}
توضیح:
تابع sub یک تابع تفریق 32 بیتی است که y را از x کم می کند. دلیل ۳۲ بیت بودن این تابع این است که حد اکثر ورودی تابع max عدد 65535 است و این عدد در یک متغیر 16 بیتی علامت دار جا نمی گیری پس ورودی را تا ۳۲ بیت علامت دار افزایش دادم.
تابع max هم عدد بزرگ تری که به این تابع پاس شده را برمیگرداند.
روش: اگر حاصل xor دو عدد را با اولین عدد xor کنیم دومین عدد بدست می آید و برعکس
قسمت اول: این تابع به صورتی کار می کند که اگر x > y بود، x را با عددی xor می کند که حاصل همان x باشد که آن عدد 0 است و هر گاه x y و -1 در شرایطی که x y باشد حاصل x – y حتما مثبت خواهد بود و اگر آن را یکی کم تر از طول متغیر (اینجا 31) به راست شیفت بدهیم حاصل 0 خواهد شد. اگر x > (31))
با سر هم کردن این سه قسمت خواهیم داشت:
return x ^ ( (x ^ y) & (uint16_t)(sub(x, y) >> (31)) )
uint16_t Max(uint16_t a,uint16_t b)
{
bool p;
uint16_t c , d;
p= ((bool)((~(a)) & (a%b))); // agar a bozorg tar bashad p = True mishavad va baraksesh p=False
c = (uint16_t)p; // p = True 1 khahad shod va p = False 0
c |= c<<1; // tamam 16 bit motaghayer c barabar ba meghdar sahihe p mi shavad
c |= c<<2;
c |= c<<4;
c |= c<<8;
d |= c&a; // javab yeki az in 2 khat barabar ba max ast va digari barabar ba 0
d |= ((~(c)) &b);
return d;
}
//4 saat fekr kardam. vaghean chand sale chalesh nadashtam. dametoon garm.
سلام
متشکر برای این که توی چالش شرکت کردید ولی جواب شما صحیح نیست اولین مشکل اینه که اگر ورودی تایع رو صفر و صفر بدیم برنامه دچار مشکل میشه (به دلیل تقسیم بر صفر) ! از این که بگذریم تعدادی از نتایج که تابع شما خلاف واقع حساب کرده رو قرار میدم
A=2,B=1 Max=1
A=3,B=1 Max=1
A=3,B=2 Max=2
A=4,B=1 Max=1
A=4,B=2 Max=2
A=5,B=1 Max=1
اول این که از اونجایی که باقی مانده بر صفر تعریف نشده است – برنامه دچار خطا میشه از اون که بگذریم باز برنامه عملکرد درستی نداره برای ورودی های زیر
A=2,B=1
A=3,B=1
A=3,B=2
A=4,B=1
A=4,B=2
سلام
پیشاپیش عید مبارک…
عجب کار جالبی انجام دادید
پاسخ رو تو یه پوشه بنام c گذاشتم و نمونه اجراش رو هم تو پوشه visual studio برای تست کردنش گذاشتم.
لینک پاسخ مسابقه:
http://s7.picofile.com/file/8391391018/for_sisoog_Second_race.rar.html
سلام خواهش میکنم
خوب روش جالبی بود که جمع و تفریق و ضرب رو به شکل منطقی پیاده سازی کردید. جواب صحیح بود
https://pastecode.xyz/view/b25dc991
سلام خواهش میکنم 🙂 روش جالبی رفتید 🙂
و برنامه شما یه خوبی کار کرد
کد تست : https://pastecode.xyz/view/e069188c
سلام و تشکر از این چالش جالب
با توجه به شرایط مسئله، برای تشخیص عدد بزرگتر باید بیت به بیت از MSB به LSB مقایسه انجام بشه و عددی که اولین بیت پر ارزشش از بیت متناظر عدد دوم بزرگتر باشه بعنوان عدد بزرگتر مشخص میشه. از جایی که از استفاده از شرط و حلقه محدود شده پس باید برنامه به صورتی پیش بره که بدون شرط توقف و اجرای کامل جواب درست رو ارائه بده. (البته برای برابری دو عدد هم قبل از محاسبه جواب، از xor استفاده شده و خروجی 2 برای برابری ورودی ها هست).
برای مقایسه بیتی با استفاده از اپراتور & باید سایر بیتها رو حذف و به تعداد لازم به سمت راست شیفت داد تا به صفر یا یک برسیم. برای بسیاری از عددها بیت های پر ارزش اولیه مشابه هستند، پس باید به روشی تشخیص داده بشه، مثل استفاده از اپراتور XOR. وقتی بیت های متناظر مشابه باشند حاصل xor صفر و در غیر اینصورت یک هست (شرط توقفی که لازم داریم متفاوت بودن بیتها هست که نتیجه xor یک بشه). برای توقف عملیات، باید نتیجه xor رو مبنای شیفت عددها قرار بدیم، پس شیفت در هر مرحله به ازای عکس جواب xor دو بیت متناظر باید باشه، پس نتیجه رو یه مرحله دیگه هم با یک xor میکنیم و در صورتی که xor دو بیت یک شده باشه، تعداد شیفت عددها برای ادامه پروسه صفر هست (همون توقفی که لازم داشتیم) تا در انتها با یه رابطه ساده بین دو بیت متناظر با مقادیر متفاوت جواب رو برگردونیم.
پ.ن. البته به دلیل محدودیت عملیات جمع و شرط و وقت بنده از تابع یا حلقه استفاده نکردم و کد نسبتا طولانی هست ولی روال واضح هست، با 16 تکرار.
// returns 0 if A is greater, 1 if B is greater, and 2 if both are equal
uint8_t findMax(uint16_t A, uint16_t B){
uint8_t len = 15; //16-1
uint16_t check = 1<>len;
b = (B&check)>>len;
//0000000000000001
m=(a^b)^1;//if m=1: (a == b), check the next bit
//check = check>>m;
A = A<<m;
B = B<>len;
b = (B&check)>>len;
//0000000000000010
m=(a^b)^1;//if m=1: (a == b), check the next bit
//check = check>>m;
A = A<<m;
B = B<>len;
b = (B&check)>>len;
//0000000000000100
m=(a^b)^1;//if m=1: (a == b), check the next bit
//check = check>>m;
A = A<<m;
B = B<>len;
b = (B&check)>>len;
//0000000000001000
m=(a^b)^1;//if m=1: (a == b), check the next bit
//check = check>>m;
A = A<<m;
B = B<>len;
b = (B&check)>>len;
//0000000000010000
m=(a^b)^1;//if m=1: (a == b), check the next bit
//check = check>>m;
A = A<<m;
B = B<>len;
b = (B&check)>>len;
//0000000000100000
m=(a^b)^1;//if m=1: (a == b), check the next bit
//check = check>>m;
A = A<<m;
B = B<>len;
b = (B&check)>>len;
//0000000001000000
m=(a^b)^1;//if m=1: (a == b), check the next bit
//check = check>>m;
A = A<<m;
B = B<>len;
b = (B&check)>>len;
//0000000010000000
m=(a^b)^1;//if m=1: (a == b), check the next bit
//check = check>>m;
A = A<<m;
B = B<>len;
b = (B&check)>>len;
//0000000100000000
m=(a^b)^1;//if m=1: (a == b), check the next bit
//check = check>>m;
A = A<<m;
B = B<>len;
b = (B&check)>>len;
//0000001000000000
m=(a^b)^1;//if m=1: (a == b), check the next bit
//check = check>>m;
A = A<<m;
B = B<>len;
b = (B&check)>>len;
//0000010000000000
m=(a^b)^1;//if m=1: (a == b), check the next bit
//check = check>>m;
A = A<<m;
B = B<>len;
b = (B&check)>>len;
//0000100000000000
m=(a^b)^1;//if m=1: (a == b), check the next bit
//check = check>>m;
A = A<<m;
B = B<>len;
b = (B&check)>>len;
//0001000000000000
m=(a^b)^1;//if m=1: (a == b), check the next bit
//check = check>>m;
A = A<<m;
B = B<>len;
b = (B&check)>>len;
//0010000000000000
m=(a^b)^1;//if m=1: (a == b), check the next bit
//check = check>>m;
A = A<<m;
B = B<>len;
b = (B&check)>>len;
//0100000000000000
m=(a^b)^1;//if m=1: (a == b), check the next bit
//check = check>>m;
A = A<<m;
B = B<>len;
b = (B&check)>>len;
//1000000000000000
x = (a^b)^1;
return ((a&(~b))^1)<<x;
}
سلام دوست عزیز با توجه به توضیحاتتون به نظر میآد برنامه تون کار کنه ولی من نتونستم تست کنم(چون ظاهرا بخش هاییش پاک شده تو کامنت و جاهایی هم علائم عوض شده) لطفا کدتون رو توی https://pastecode.xyz/ آپلود کنید و در جواب همین کامنت قرار بدید. تنها 24 ساعت برای این گزینه فرصت هست
متشکرم
سلام، بله مثل این که کد بهم ریخته بود. لینک کد: https://pastecode.xyz/view/8cef4e22
ممنون
https://onlinegdb.com/rJbqcoEUU تست کنید خودتون جواب های اشتباه و می بینید
https://pastecode.xyz/view/8cef4e22
کد شما بررسی شد – عملکرد صحیحی نداشت برای ورودی های زیر خروجی نامناسبی رو ارائه می کرد.
About • FAQ • Blog • Terms of Use • Contact Us • GDB Tutorial • Credits • Privacy
© 2016 - 2020 GDB Online
Language
main.c
input
A=0,B=0 Max=2
A=0,B=2 Max=1
A=0,B=3 Max=1
A=0,B=4 Max=1
A=0,B=5 Max=1
کد تست : https://onlinegdb.com/SJXFeoNUU
خروجی کد به این شکل هست که درصورتی که ورودی اول A بزرگتر باشه عدد 0 برمیگردونه، اگر خروجی دوم B بزرگتر باشه عدد 1 برمیگردونه و درصورت تساوی عدد 2 رو برمیگردونه. نمیدونستم به چه شکلی تست میکنید کد رو وگرنه تابع رو ویرایش میکردم
اوکی متوجه شدم چی شد
خوب قرار بود که تابع عدد بزرگتر رو برداند ! من دارم کد شما رو میذارم تو یه تابع که خروجیش رو با عدد بزرگتر مقایسه میکنه برای همینه که داره اشتباه میشه!
تابعتون باید اینطور می بود :
https://pastecode.xyz/view/7b20fefb
ولی خوب قبول می کنیم
جواب من با لینک کد ثبت نمیشه، لطفا مشکل رو بررسی کنید
ما این جواب را داریم از شما
https://pastecode.xyz/view/8cef4e22
درسته همینه دیگه؟ پیعام هم داده بودید تلگرام
بله درسته ممنون
#include
#include
int main()
{
int a,b,c;
printf(“Enter 2 Number:\n”);
scanf(“%d %d”, &a, &b);
printf(“Max number is %d \n”,FindMaxNumber( a,b ));
}
int FindMaxNumber( int x, int y)
{
int z = x – y;
int i = (z >> 31) & 0x1;
printf(“i = %d shift = %d \n”, i, (z>>31));
int finalmax = x – i * z;
return finalmax;
}
این جواب داد. امیدوارم برنده بشم چون خیلی به او اون آموزش نیازدارم
سلام دوست عزیز چرا از عمل وند های منهی و ضرب که ناقض شرایط مسابقه هستند استفاده کردید ؟
درود بر شما؛
بنده با استفاده از OR و XOR جواب گرفتم:
uint16_t Max(uint16_t num1 , uint16_t num2){
uint16_t num3 = num1 || num2;
uint16_t num4 = num3 ^ num2;
uint16_t num5 = num4 ^ num1;
return (num4 || num5);
}
اصلاح میکنم در تایپ اشتباهاً بجای | از || استفاده کردم که همان | یا OR صحیح است:
uint16_t Max(uint16_t num1 , uint16_t num2){
uint16_t num3 = num1 | num2;
uint16_t num4 = num3 ^ num2;
uint16_t num5 = num4 ^ num1;
return (num4 | num5);
}
باز فرقی نمی کنه برای همون ورودی ها چک کنید
منطقا نباید به این سادگی می بود – کدتون رو برای ورودی های
A=0,B=1
A=0,B=2
A=0,B=3
A=0,B=4
A=0,B=5
چک کنید چواب صحیح نیست
سلام
شاید جایزه ای که تعیین کردید آنقدر توجیه اقتصادی نداشته باشه و یا اینکه انگیزه ای در دوستان ایجاد نکنه که روی این تست وقت بذارن.
بنده هم یه زمان خالی اندک پیدا کردم و دم دست ترین جواب رو برای این آزمون نوشتم، البته مطمئنم که به شرط صرف زمان کافی، راه های خیلی ساده تری هم برای این کار وجود داره.
اساس راه حل اینجانب به این شکله که سه تابع برای برگرداندن مقادیر ماکسیمم، جمع به روش بیتی و ضرب بیتی داره.
البته این برنامه رو تو کامپایلر زبان c به نام dev-C++ نوشتم و تست کردم که فایلش موجوده، به خاطر همین کدهاش به این شکله؛
توضیح کد: ابتدا مقادیر از کاربر دریافت میشن و در رجیسترهای a و b ذخیره میشن.
سپس توسط تابع sum و با استفاده از مکمل 1، مقدار b از a کسر میشه؛
در صورتی که b از a بزرگتر باشه، بیت شانزدهم رجیستر حاصل این تفریق برابر 1 میشه، در غیر این صورت این بیت برابر صفر باقی می مونه.
حالا با استفاده از تابع bitMul، اگر بیت 16 که گفتم برابر 0 باشه مقدار a رو برمیگردونه و اگر این بیت برابر صفر باشه مقدار b رو برمیگردونه.
توجه داشته باشید که هم خودِ این بیت(بیت شانزدهم) و هم ناتِِش در a یا b ضرب میشن ، بنابراین صرف نظر از اینکه این مقادیر با هم جمع میشن، در آنِ واحد مقدار خروجی فقط برابر یکی از مقادیر a یا b خواهد بود که این مقدار همون مقدار ماکسیمم هست.
کد:
using namespace std;
unsigned short int max(unsigned short int a, unsigned short int b);// return maximum value
int sum(int a, int b);// resurn a+b
signed short int bitMul(signed short int a, char b);//this function will return a if b=1, else returns 0
int main() {
unsigned short int a,b;// a and b are unsigned 16 bit values.
cout <<" enter the first number: "<> a;
cout <<" enter the second number: "<> b;
cout <<" —————— " << "\n"<< endl;
cout <<" maximum is: "<< max(a,b) << "\n"<aa=aa-bb
return sum(bitMul(a,~aa>>16 &1),bitMul(b,aa>>16 &1)); // if a is les than b, so the sixteenth bit is 1, else it is 0
}
int sum(int a , int b)
{
int carry ;
carry = a & b;
a = a ^ b;
b=carry << 1;
carry = a & b;
a = a ^ b;
b=carry << 1;
carry = a & b;
a = a ^ b;
b=carry << 1;
carry = a & b;
a = a ^ b;
b=carry << 1;
carry = a & b;
a = a ^ b;
b=carry << 1;
carry = a & b;
a = a ^ b;
b=carry << 1;
carry = a & b;
a = a ^ b;
b=carry << 1;
carry = a & b;
a = a ^ b;
b=carry << 1;
carry = a & b;
a = a ^ b;
b=carry << 1;
carry = a & b;
a = a ^ b;
b=carry << 1;
carry = a & b;
a = a ^ b;
b=carry << 1;
carry = a & b;
a = a ^ b;
b=carry << 1;
carry = a & b;
a = a ^ b;
b=carry << 1;
carry = a & b;
a = a ^ b;
b=carry << 1;
carry = a & b;
a = a ^ b;
b=carry << 1;
carry = a & b;
a = a ^ b;
return a;
}
signed short int bitMul(signed short int a, char b)
{
return (a&b | a&b<<1 | a&b<<2 | a&b<<3 | a&b<<4 | a&b<<5 | a&b<<6 | a&b<<7 | a&b<<8 | a&b<<9 | a&b<<10 | a&b<<11 | a&b<<12 | a&b<<13 | a&b<<14 | a&b<<15);
}
سلام
مساله همیشه جایزه نیست ، گاهی آدم دوست داره خودش به چالش بکشه و مسائل رو جور دیگه ای نگاه کنه ! شاید مساله این باشه
دوست عزیز من کد شما رو نتونستم بررسی کنم چون مثلا متغییر aa هیچ کجا مقدار دهی درستی نشده یا مثلا متغییر bb که تعریف کردید اصلا جایی تعریف نشده و.. اگه امکان داره فایلتون رو بفرستید برای قرار دادن کد میتونید از سرویس https://pastecode.xyz/ استفاده کنید.
قطعاً همینطوره؛ چالش جالبی بود، خصوصاً برای کسانی که به زبان های سطح بالا عادت کردن!
اینم کد بنده که در صورتی که تو یه کامپایلر زبان C کپی بشه، بدون مشکل کار میکنه:
https://pastecode.xyz/view/8502545f
خواهش میکنم دوست عزیز 🙂
خوب من کد شما و بررسی کردم برای برخی ورودی ها درست عمل نمیکنه
https://onlinegdb.com/SkcCOsVLU
اینجا خودتون ببینید
برای پاسخ سوال باید دو عدد را یک بار با هم جمع بزنیم و یک بار عدد کوچکتر را از عدد بزرگتر کسر کرد و با مجموع قبلی جمع زد. حال نتیجه را بر دو تقسیم میکنیم عدد بزرگتر مشخص میگردد:
#include
#include
int main()
{
int x, y;
printf(“Enter two numbers:\n”);
scanf(“%d %d”, &x, &y);
//finding largest number between two
printf(“\nLargest number: %d\n”, ((x + y) + abs(x – y)) / 2);
return 0;
}
سلام – این روش کاملا درسته ولی خوب باید شرایط مسابقه رو هم در نظر بگیرید !
استفاده از جمع و تفریق و تقسیم غیر مجازه !!
با سلام و تشکر بابت مطالب مفید سایتتون.
خب من محدودیت استفاده از حلقه رو کامل متوجه نشدم و برای همین کنارش گذاشتم .
تابع ای که من نوشتم 8 خط اصلی داره که تکرار میشه به خاطر محدودیت های مسابقه باید از عملگر های منطقی استفاده کرد. در این تابع بیت به بیت از با ارزش ترین بیت تا بیت آخر از اعداد به وسیله کد های زیر استخراج میشه
a = x & (1<>= N;
b = y & (1<>= N;
در این جا N عدد ثابتی است که از 15 شروع شد ( برای با ارزش ترین بیت)در قسمت اول و تا 0 در آخرین قسمت که کد تکرار می شود ادامه پیدا می کند.
در مرحله بعد به وسیله کد زیر مساوی نبودن آن ها مشخص شده که نشان دهنده این است که یکی از اعداد بزرگتر از دیگری است
flagغ = a ^ b;
چون متغیر بزرگ برایمان مهم هست، پس از پیدا کردن اولین بیت با ارزش متفاوت متغیر کوچک تر را صفر کرده تا در تکرار های بعدی نتیجه تغیر نکند این کار با استفاده از آرایه : Arr[2]={0,0xffff} در کد زیر انجام میشود
flag = (~flag) & 1;
x &= Arr[a | flag];
y &= Arr[b | flag];
خط اول نتیجه فلگ را به صورت یک بیت نات می کند و در خط های بعد با اند شدن آرایه با x , y متغیر کوچک تر صفر می شود بدین صورت که اگر نات فلگ 1 باشد یعنی متغیر ها با هم مساوی بوده و بدون توجه به مقدار a , b در مقدار 0xffff اند می شوند که یعنی هیچکدام تغیر نمی کند اما اگر نات flag صفر باشد یعنی متغیر کو چک تر بیت متناظر آن 0 است و فلگ 0 است در نتیجه با اند شدن در 0 ، صفر و بی اثر شده.
در خط آخر متغیر بزرگتر حاصل OR هردو متغیر می باشد چون متغیر کوچک تر صفر شده نتیجه همیشه متغیر بزرگ هست و در صورت مساوی بودن نیز مشکلی ایجاد نشده
large = x | y;
printf(“large %x”,large);
;return large
تابع کامل:
unsigned int Max( unsigned int x ,unsigned int y ){
unsigned int a=0,b=0;
unsigned int Arr[2]={0x0,0xffff};
unsigned int flag=0;
unsigned int large =0;
a = x & (1<>= 15;
b = y & (1<>= 15;
flag = a ^ b;
flag = (~flag) & 1;
x &= Arr[a | flag];
y &= Arr[b | flag];
a = x & (1<>= 14;
b = y & (1<>= 14;
flag = a ^ b;
flag = (~flag) & 1;
x &= Arr[a | flag];
y &= Arr[b | flag];
a = x & (1<>= 13;
b = y & (1<>= 13;
flag = a ^ b;
flag = (~flag) & 1;
x &= Arr[a | flag];
y &= Arr[b | flag];
a = x & (1<>= 12;
b = y & (1<>= 12;
flag = a ^ b;
flag = (~flag) & 1;
x &= Arr[a | flag];
y &= Arr[b | flag];
a = x & (1<>= 11;
b = y & (1<>= 11;
flag = a ^ b;
flag = (~flag) & 1;
x &= Arr[a | flag];
y &= Arr[b | flag];
a = x & (1<>= 10;
b = y & (1<>= 10;
flag = a ^ b;
flag = (~flag) & 1;
x &= Arr[a | flag];
y &= Arr[b | flag];
a = x & (1<>= 9;
b = y & (1<>= 9;
flag = a ^ b;
flag = (~flag) & 1;
x &= Arr[a | flag];
y &= Arr[b | flag];
a = x & (1<>= 8;
b = y & (1<>= 8;
flag = a ^ b;
flag = (~flag) & 1;
x &= Arr[a | flag];
y &= Arr[b | flag];
a = x & (1<>= 7;
b = y & (1<>= 7;
flag = a ^ b;
flag = (~flag) & 1;
x &= Arr[a | flag];
y &= Arr[b | flag];
a = x & (1<>= 6;
b = y & (1<>= 6;
flag = a ^ b;
flag = (~flag) & 1;
x &= Arr[a | flag];
y &= Arr[b | flag];
a = x & (1<>= 5;
b = y & (1<>= 5;
flag = a ^ b;
flag = (~flag) & 1;
x &= Arr[a | flag];
y &= Arr[b | flag];
a = x & (1<>= 4;
b = y & (1<>= 4;
flag = a ^ b;
flag = (~flag) & 1;
x &= Arr[a | flag];
y &= Arr[b | flag];
a = x & (1<>= 3;
b = y & (1<>= 3;
flag = a ^ b;
flag = (~flag) & 1;
x &= Arr[a | flag];
y &= Arr[b | flag];
a = x & (1<>= 2;
b = y & (1<>= 2;
flag = a ^ b;
flag = (~flag) & 1;
x &= Arr[a | flag];
y &= Arr[b | flag];
a = x & (1<>= 1;
b = y & (1<>= 1;
flag = a ^ b;
flag = (~flag) & 1;
x &= Arr[a | flag];
y &= Arr[b | flag];
a = x & (1<>= 0;
b = y & (1<>= 0;
flag = a ^ b;
flag = (~flag) & 1;
x &= Arr[a | flag];
y &= Arr[b | flag];
large = x | y;
printf(“large %x”,large);
;return large
}
http://s7.picofile.com/file/8391353468/main_1_.c.html
جالبه من اون کد رو خودم دستی اصلاح کردم کار نکرد باز ولی این کد به خوبی کار کرد معادل تست برنامه زیر
https://pastecode.xyz/view/03b543f6#L21
برنامه شما مطابق کد https://pastecode.xyz/view/0a939cf8 تست شد و عملکرد صحیحی نداشت
A=0,B=2 Max=0
A=0,B=3 Max=1
A=0,B=4 Max=0
A=0,B=5 Max=0
A=0,B=6 Max=0
من ی خط تو کدم هست که وقتی کامنت می کردم کلا حذف می شد
15=<<b
بخاطر این تست اولتون اشتباه شده
ولی بعد ها تایید شد فکر کنم 🙂
با سلام
روش كار : با جمع دو عدد ورودي و سپس جمع زدن با حاصل تفريق دو عدد ورودي و سپس تقسيم بر ٢
چون حاصل تفريق ممكن است منفي شود بنابراين از abs براي حاصل تفريق استفاده ميكنيم
مثال:
x=8
y=12
(8+12)+ abs(8-12)= 12
……………………………………………..
include
#include
int main()
{
int x, y;
printf(“Enter :\n”);
scanf(“%d %d”, &x, &y);
printf(“\n BooZorgtarin: %d\n”, ((x + y) + abs(x – y)) / 2);
return 0;
}
سلام روش درسته ولی در شرایط مسابقه در جواب دیده نمشه – از جمع و منهی توی برنماه استفاده شده در ضمن تابع abs رو باید بدون شرط باز نویسی میکردید.
#include
#include
#include
uint16_t Mm,Nn;
char A(char a);
char B(char b);
char S(char d);
uint16_t compare(void);
int main()
{
scanf(“%d%d”,&Mm,&Nn);
printf(“a=%d”,compare());
}
char A(char a)//give the bite that we want in first number
{
return (Mm&(1<>a;
}
char B(char b)//give the bite that we want in second number
{
return (Nn&(1<>b;
}
char S(char d)//give XNOR of two bite
{
return (~(A(d) ^ B(d)))&1;
}
uint16_t compare(void)
{
char flag = A(15)&(~B(15)) | S(15)&A(14)&(~B(14)) | S(15)&S(14)&A(13)&(~B(13)) | S(15)&S(14)&S(13)&A(12)&(~B(12)) | S(15)&S(14)&S(13)&S(12)&A(11)&(~B(11)) | S(15)&S(14)&S(13)&S(12)&S(11)&A(10)&(~B(10)) | S(15)&S(14)&S(13)&S(12)&S(11)&S(10)&A(9)&(~B(9)) | S(15)&S(14)&S(13)&S(12)&S(11)&S(10)&S(9)&A(8)&(~B(8)) | S(15)&S(14)&S(13)&S(12)&S(11)&S(10)&S(9)&S(8)&A(7)&(~B(7)) | S(15)&S(14)&S(13)&S(12)&S(11)&S(10)&S(9)&S(8)&S(7)&A(6)&(~B(6)) | S(15)&S(14)&S(13)&S(12)&S(11)&S(10)&S(9)&S(8)&S(7)&S(6)&A(5)&(~B(5)) | S(15)&S(14)&S(13)&S(12)&S(11)&S(10)&S(9)&S(8)&S(7)&S(6)&S(5)&A(4)&(~B(4)) | S(15)&S(14)&S(13)&S(12)&S(11)&S(10)&S(9)&S(8)&S(7)&S(6)&S(5)&S(4)&A(3)&(~B(3)) | S(15)&S(14)&S(13)&S(12)&S(11)&S(10)&S(9)&S(8)&S(7)&S(6)&S(5)&S(4)&S(3)&A(2)&(~B(2)) | S(15)&S(14)&S(13)&S(12)&S(11)&S(10)&S(9)&S(8)&S(7)&S(6)&S(5)&S(4)&S(3)&S(2)&A(1)&(~B(1)) | S(15)&S(14)&S(13)&S(12)&S(11)&S(10)&S(9)&S(8)&S(7)&S(6)&S(5)&S(4)&S(3)&S(2)&S(1)&A(0)&(~B(0));
flag = flag<<15 | flag<<14 | flag<<13 | flag<<12 | flag<<11 | flag<<10 | flag<<9 | flag<<8 | flag<<7 | flag<<6 | flag<<5 | flag<<4 | flag<<3 | flag<<2 | flag<<1;
return Mm&flag | Nn&(~flag);
}
ورودی های زیر رو به برنامه بدید – خروجی اشتباه خواهد بود
A=1,B=0
A=1,B=2
A=1,B=4
A=1,B=6
A=1,B=8
سلام خسته نباشین.
بله بعد ها متوجه اشتباهم شدم دو تا فایل دیگه فرستادم که سومی کاملا درست بود
بله درست میگین.دوبار متوجه اشتباهم شدم و اصلاح شدشو(سومین فایلی که فرستادم) قبل از پایان مسابقه ارسال کردم
#include
uint16_t bigness_detector(uint16_t a, uint16_t b)
{
/* the idea is to make the cpu simulate something like a 16-bit digital comparator! */
uint16_t xor=0;
uint16_t greater_a_indicator=0;
uint16_t cyclic_or=0;
uint16_t a_validator_mask=0;
/* in fact, we need XNOR, but XOR simplifies the code */
xor = a ^ b;
greater_a_indicator = a & ~b;
/* append 1 instead of 0 in shift operations */
greater_a_indicator &= ~(xor >> 1)
& ~(xor >> 2)
& ~(xor >> 3)
& ~(xor >> 4)
& ~(xor >> 5)
& ~(xor >> 6)
& ~(xor >> 7)
& ~(xor >> 8)
& ~(xor >> 9)
& ~(xor >> 10)
& ~(xor >> 11)
& ~(xor >> 12)
& ~(xor >> 13)
& ~(xor >> 14)
& ~(xor >> 15);
/* if greater_a_indicator is something other than zero, the “a” is bigger, otherwise “b” would be the return value (either “a” equals to “b” or “a” is less than “b”) */
/* OR all the bits of greater_a_indicator */
cyclic_or = ((greater_a_indicator >> 0) & (uint16_t)0x0001) |
((greater_a_indicator >> 1) & (uint16_t)0x0001) |
((greater_a_indicator >> 2) & (uint16_t)0x0001) |
((greater_a_indicator >> 3) & (uint16_t)0x0001) |
((greater_a_indicator >> 4) & (uint16_t)0x0001) |
((greater_a_indicator >> 5) & (uint16_t)0x0001) |
((greater_a_indicator >> 6) & (uint16_t)0x0001) |
((greater_a_indicator >> 7) & (uint16_t)0x0001) |
((greater_a_indicator >> 8) & (uint16_t)0x0001) |
((greater_a_indicator >> 9) & (uint16_t)0x0001) |
((greater_a_indicator >> 10) & (uint16_t)0x0001) |
((greater_a_indicator >> 11) & (uint16_t)0x0001) |
((greater_a_indicator >> 12) & (uint16_t)0x0001) |
((greater_a_indicator >> 13) & (uint16_t)0x0001) |
((greater_a_indicator >> 14) & (uint16_t)0x0001) |
((greater_a_indicator >> 15) & (uint16_t)0x0001);
cyclic_or &= (uint16_t)0x0001;
/* reproduce the least significant bit of cyclic_or to fill up the entire a_validator_mask bits */
a_validator_mask = (cyclic_or << 0) |
(cyclic_or << 1) |
(cyclic_or << 2) |
(cyclic_or << 3) |
(cyclic_or << 4) |
(cyclic_or << 5) |
(cyclic_or << 6) |
(cyclic_or << 7) |
(cyclic_or << 8) |
(cyclic_or << 9) |
(cyclic_or << 10) |
(cyclic_or << 11) |
(cyclic_or << 12) |
(cyclic_or << 13) |
(cyclic_or << 14) |
(cyclic_or << 15);
return (a & a_validator_mask) | (b & ~a_validator_mask);
}
بله کاملا درسته 🙂
کد تست : https://pastecode.xyz/view/0dc74004
باسلام
جوابی که بنده برای این موضوع پیدا کردم به شرح زیر می باشد:
#include
int main ()
{
unsigned short x, y;
int r;
char *Px, *Pxx;
x = 655;
y = 6553;
Px = 0;
Px = &Px[x];
Pxx = Px;
Px = &Px[-y];
r = Px;
// r = x – ((x – y) & ((x – y) >> (sizeof(int) * CHAR_BIT – 1))); // max(x, y)
r = (r & (r >> 31));
Pxx = &Pxx[-r];
r = Pxx;
printf (“%i\n”, r);
return 0;
}
نحوه عملکرد:
بنده برای حل از یکی از کامنت ها داخل سایت codegolf.stackexchange.com الهام گرفتم:
https://codegolf.stackexchange.com/a/6863
در این کامنت برای عدم استفاده از علامت + یا – از ترکیب پوینتر و اندیس آرایه ها استفاده کرده بود برایم سوال شد و در اینترنت به جستجو پرداختم تا برایش جواب مناسبی پیدا کنم. در سایت ویروگل به آدرس https://virgool.io/@amn/%D8%A7%D8%B4%D8%A7%D8%B1%D9%87-%DA%AF%D8%B1%D9%87%D8%A7-%D8%AF%D8%B1-%D8%B3%DB%8C-hrt7avsu6zgg
یک عکس یافتم که موضوع برایم شفاف تر شد و آن این عکس هست:
https://files.virgool.io/upload/users/3157/posts/hrt7avsu6zgg/xrjy9a6xcarz.png
که در آن اشاره شده است که :
char ch[], *Pch;
ch==&ch==&ch[0]
و بعد
Pch=&ch[0];
معرفی شده یعنی یه آرایه همون پوینتر به آدرس اولشه و یا یه پوینتر به عنوان آغاز یه آرایه در نظر گرفته میشه و یکی از عیوب سی که در اینجا به ما کمک می کند برای حل مسئله اینه که هیچ وقت چک نمیشه آیا به آخر اندیس آرایه رسیدیم؟ نرسیدیم؟ رد کردیم؟ و… (البته فکر کنم php در این مورد سخت گیر تر هست)و در آدرس زیر عنوان شده که برای افزایش سرعت هستش؟!
http://www.hamcodi.ir/qa/questions/2524/%D8%A8%D8%AF%D8%B3%D8%AA-%D8%A2%D9%88%D8%B1%D8%AF%D9%86-%D8%B7%D9%88%D9%84-%D8%A2%D8%B1%D8%A7%DB%8C%D9%87-%D8%AF%D8%B1-c
برای نمونه اگر کد زیر رو در کامپایلر سی بنویسید بهتر متوجه میشید:
char a[20]={1,2,3,4,5,6,7,8,9};
printf(“sizeof a:%ld\n”,sizeof(a)/sizeof(a[0]));
printf(“a[40]:%d\n”,a[40]);
متغییر a[40] وجود خارجی نباید داشته باشه (البته از نظر ما) اما برخلاف تصور خروجی داره و هر بار یه چیزی رندم چاپ میشه.
خوب برم سراغ توضیح کد:
اول اینو بگم چون اینجا نمیشه کد ها رو توچین و یا چپ چین کرد با اجازه تون برای فهم بهتر و مشاهده آنلاین نتیجه در آدرس زیر قرار دادم:
https://onlinegdb.com/HkFA_30SU
و نکته دوم اینکه چون در صورت مسئله گفته شده که متغییر 16 بیتی و در زبان سی برای pc طول متغییر int 4 بایت یا 32 بیت در نظر گرفته شده بنابراین از short استفاده کردم.
فرمول محاسبه که بنده استفاده کردم برابر :
r = x – ((x – y) & ((x – y) >> (sizeof(int) * CHAR_BIT – 1))); // max(x, y)
است که در ادامه توضیح می دهم.
در ابتدا که متغییر ها تعریف شده اند دو تا 16 بیتی، یکی 32 بیتی و یک پوینتر 8 بیتی. x ,y همون ورودی هامون هستند که به صورت دلخواه تعریف میشه.
در خط 12 آدرس خانه حافظه صفر را به اشاره گر می دهیم یعنی اشاره گر به آدرس صفر اشاره می کند.
در خط 13 آدرس خانه x ام از یه آرایه (همون اشاره گر) را پیدا کرده و در اشاره گر ذخیره می کنیم از آنجا که آدرس شروع آرایه؛ صفر در نظر گرفته شده و آرایه 8 بیتی هست آدرس x برابر x هست.
اینکه چرا از اشاره گر 8 بیتی استفاده کردم هم اینجا مشخص میشه چون حافظه بایتی تقسیم بندی میشه اگر آرایه یا همون اشاره گر بصورت 16 بیتی تعریف بشه اگر بخوایم به عضو x ام اشاره کنم آدرسش چون پرش ها دوتا دوتا میشه، برابر 2*x میشه!
در خط 14 از آدرس فعلی که برابر ایکس هست به اندازه متغییر دوم که y هست به عقب برمی گردیم و آدرس جدید را در یک متغییر کمکی ذخیره می کنیم یه جورایی به راحتی اختلاف دو متغیر ورودی مشخص میشه و در r ذخیره میشه. اگر x بزرگتر از y باشه مشکلی نیست و آدرس جدید بین 0 تا x هست اما اگر y بزرگتر از x باشه به عدد منفی می رسیم .برای نگه داری این عدد نیاز به متغییر داریم که بتونه مثبت و منفی عدد های x , y رو داخل خودش نگه داره پس نیاز هست که این عدد به صورت 32 بیتی و با علامت تعریف بشه، همون r.
در خط 15 با کمک همین بیت آخر یا 32، معما حل میشه زیرا اگر بیت آخر 0 باشه یعنی x بزرگتره و باید مقدار x برگردونده بشه بنابراین مقدار r با عملیات and با بیت آخر(32) متغییر r صفر میشه و عملا خط 16 هم تغییر خاصی بر روی اشاره گر نداره و به همون جای قبلی (x) اشاره میکنه. اما اگر این مقدار منفی بشه طبق مطلبی که قبلا در سایت قرار دادین و عنوان “رفتاری که به آن توسعه علامت گفته میشه” و در آدرس زیر :
https://sisoog.com/2017/05/bitshift-operators/
گفتین، همه بیت های حاصلr >> 31 برابر یک میشه و عملا خود مقدار r در خودش ذخیره میشه و مقدار r یا همون اختلاف پس از تغییر علامت با عدد x جمع میشه تا به عدد بزرگتر یعنی y برسیم و در خط 19 هم به عنوان خروجی به کاربر نمایش بدیم.
یه فرض مهم که باید اینجا در نظر بگیریم اینه که فضای حافظه فکر کنم (مطمئن نیستم) باید از محدوده متغییر 16 بیتی (65535 بایت بزرگتر باشه تا عملیات با خطا مواجه نشه (طبق نظر این دوستمون در این آدرس: https://www.researchgate.net/post/What_is_the_maximum_size_of_an_array_in_C)
از اینکه تونستم داخل این چالش شرکت کنم و مطالب جدیدی یاد بگیرم خیلی خوشحالم.
سلام
خوب شما دارید همون جمع و منها رو انجام میدید ولی خوب با آدرس حافظه این کار رو انجام میدید 😐
اگر از علامت منفی استفاده نمی کردید برنامتون درست بود ولی الان میشه گفت ناقض شرط های مسابقه است
ولی روش جالبی بود
سلام این مورد هم اگرچه اول دقت نکرده بودم اما با روشی که اینجا پیدا کردم قابل حله:
به جای -y ابتدا به اندازه ~y پیشروی و بعد دوباره یه مرحله به اندازه یکی پیشروی می کنیم.
الان جوابتون رو دیدم وگرنه کد کاملشو دوباره می نوشتم.
در کل روش جالبی برام بود
بازم ممنون
واقعا روش جالبی بود شما طی 24 ساعت همین کد رو مشکلش رو برطرف کنید من قبول میکنم
فقط بخاطر خاص بودنش و جنبه آموزشی 🙂
سلام
ببخشید اینم کد اصلاح شده:
#include
int main ()
{
unsigned short x, y;
int r;
char *Px;
// r = x – ((x – y) & ((x – y) >> (sizeof(int) * CHAR_BIT – 1))); // max(x, y)
x = 1;
y = 0;
Px = 0;
Px = &Px[x];
//r = &Px[-y];
Px = &Px[~y];
Px = &Px[1];
r = Px;
r = (r & (r >> 31));
//Px = &Px[-r];
Px=0;
Px = &Px[~r];
Px = &Px[1];
r=Px;
Px = 0;
Px = &Px[x];
Px = &Px[r];
printf (“%i\n”, Px);
return 0;
}
اینم لینکش:
https://onlinegdb.com/BJU8jh7LU
به خوبی کار کرد – یکی از متفاوت ترین جواب هایی این چالش بود:)
کد تست : https://pastecode.xyz/view/1d9c21af
سلام
از cast کردن که میشه استفاده کرد؟
بله میشه قطعا استفاده کرد.
خب راه‌‌های متفاوتی برای این برنامه وجود دارد، اما من سعی کردم با پایین‌ترین سطح ممکن این برنامه را بنویسم و تنها از and or not استفاده کردم. در واقع با جبر بول اون توابعی که عمل مقایسه را انجام می‌دهد را استخراج کردم و به زبان C نوشتم.
برنامه به این صورت است که دو عدد از شما دریافت میکند و در نهایت پاسخ می‌دهد که کدام یگ از این اعداد بزرگتر است، و اگر هم که مساوی باشند، می‌گوید که این اعداد مساوی هستند.
به علت اینکه تعداد خطوط برنامه زیاد بود، کد راکپی نکردم و در لینک زیر قابل مشاهده است:
http://uupload.ir/filelink/S4gw5mRZ8kAL/484b_compare.txt
🙂 برنامه شما هم کاملا صحیحه
البته دیگه لازم نبود مساوی و کوچکتر رو حساب کنی 🙂
unsigned int func1(unsigned int a,unsigned int b)
{
(return (aORb) AND (aOR~b
}
خوب کافیه ورودی های زیر رو به برنامه بدید تا ببینید درست کار نمیکنه
A=1,B=0
A=2,B=0
A=2,B=1
A=3,B=0
A=3,B=1
سلام
وقت بخیر
میشه از منفی پشت متغیر استفاده کرد؟ مثل:
x = -y
سلام ، وقت شما هم بخیر
نه مطابق پیش شرط ها مجاز نیست
ببخشید
یک سوال دیگه
«نباید از عملیات جمع و منهی استفاده شود (-,+,-=,+=)» با توجه به این
اگه یه تابع بنویسیم که کار جمع رو انجام بده و از اپراتور هایی که تو شرط گفتین هم استفاده نکنه باز شرط رو نقض می کنه؟
نه این اشکالی نداره و میتونید این کار رو انجام بدید 🙂
ممنون
سلام از دستورات while و for به هیچ وجه نمیتوان استفاده کرد؟
درصورت امکان نمونه صحیحی از استفاده از این دستورات را ذکر بفرمایید
وقتی میگیم شرط های حلقه مجاز نیستند ! یعنی دارم استفاده از حلقه محدود میکینم
مثلا میتونید از for(;;) استفاده کنید یعنی از شرطش استفاده نکردید
سلام. خسته نباشید.
اینو تو کامپایلر نوشتم هم چک کرده باشم هم تمیز تر بهتون ارائه بدم. چون کپی کردم کد خراب شد.
https://onlinegdb.com/S12vY_pSL
اول توضیح تابع دوم که ساده تر هست و اینکه یه ربط هایی هم به تابع اول داره! خیلی واضحه! ما مثل این هست که داریم B رو بررسی میکنیم اگر B بزرگتر باشه اندیس یک میشه و خروجی B میشه در غیر این صورت اندیس صفر و A خروجی میشه!
تابع اول… اول اینکه میدونیم x^x^y برابر با y هست حالا ما از یک ثابت استفاده میکنیم و یکم پرانتر بازی میکنیم! : (x^((x^y)&c خب….حالا اون c یک عدد هست ما باید کاری کنیم اگر x عدد بزرگتر بود c صفر بشه تا داخل پرانتز رو صفر کنه و xor صفر با یک عدد میشه خود عدد یعنی x. اگر هم y بزرگتر بود سی باید یک عدد 0xFFFF بشه که در حقیقت اثر & رو حذف کنه بشه همون عبارتی که اول گفتم و جواب y بشه. که با توجه به چیزی که گفتم c باید [array[x<y باشه که شرط c رو ارضا میکنه.
خیلی ممنون.
سلام و درود
شما که توی هر دو تا تابع از عبارت مقایسه ای استفاده کردید ؟! که شرایط مسابقه رو نقض میکنه
بله. حق با شماست ظاهرا قوانین رو با دقت نخوندم. 🙂
با سلام و احترام،
با توجه به شروطی که گذاشتید، چیزی که مد نظر شماست digital comparator یا magnitude comparator هست که معمولا یک سخت افزاره مثل آی سی 74HC85 و یا در دل CPU ها و MCU ها قرار داره و پیاده سازی نرم افزاری اش توجیح نداره!
https://en.wikipedia.org/wiki/Digital_comparator
https://learnabout-electronics.org/Digital/dig43.php
در هر صورت، من این رو نوشتم ….
//—————- WORD_BYTES 16-bit
typedef union _WORD_BYTES {
WORD word;
BYTE bytes[2];
struct {
BYTE LB;
BYTE HB;
} byte;
struct {
unsigned char bit0:1;
unsigned char bit1:1;
unsigned char bit2:1;
unsigned char bit3:1;
unsigned char bit4:1;
unsigned char bit5:1;
unsigned char bit6:1;
unsigned char bit7:1;
unsigned char bit8:1;
unsigned char bit9:1;
unsigned char bit10:1;
unsigned char bit11:1;
unsigned char bit12:1;
unsigned char bit13:1;
unsigned char bit14:1;
unsigned char bit15:1;
} bits;
} WORD_BYTES;
unsigned int Compar(unsigned int inA, unsigned int inB)
{
unsigned char AcaB, AcoB;
unsigned int Bnt;
WORD_BYTES ABnt, AxnB;
unsigned int AgB, Rslt;
//——————–
Bnt = ~inB;
ABnt.word = inA &Bnt;
AxnB.word = ~(inA ^inB);
//——————–
AcoB = ABnt.bits.bit15;
AcaB = AxnB.bits.bit15;
AcoB |= (ABnt.bits.bit14 &AcaB);
AcaB &= AxnB.bits.bit14;
AcoB |= (ABnt.bits.bit13 &AcaB);
AcaB &= AxnB.bits.bit13;
AcoB |= (ABnt.bits.bit12 &AcaB);
AcaB &= AxnB.bits.bit12;
AcoB |= (ABnt.bits.bit11 &AcaB);
AcaB &= AxnB.bits.bit11;
AcoB |= (ABnt.bits.bit10 &AcaB);
AcaB &= AxnB.bits.bit10;
AcoB |= (ABnt.bits.bit9 &AcaB);
AcaB &= AxnB.bits.bit9;
AcoB |= (ABnt.bits.bit8 &AcaB);
AcaB &= AxnB.bits.bit8;
AcoB |= (ABnt.bits.bit7 &AcaB);
AcaB &= AxnB.bits.bit7;
AcoB |= (ABnt.bits.bit6 &AcaB);
AcaB &= AxnB.bits.bit6;
AcoB |= (ABnt.bits.bit5 &AcaB);
AcaB &= AxnB.bits.bit5;
AcoB |= (ABnt.bits.bit4 &AcaB);
AcaB &= AxnB.bits.bit4;
AcoB |= (ABnt.bits.bit3 &AcaB);
AcaB &= AxnB.bits.bit3;
AcoB |= (ABnt.bits.bit2 &AcaB);
AcaB &= AxnB.bits.bit2;
AcoB |= (ABnt.bits.bit1 &AcaB);
AcaB &= AxnB.bits.bit1;
AcoB |= (ABnt.bits.bit0 &AcaB);
//——————–
AgB = 0x0000;
for(i=0; i<16; i++) AgB |= (AcoB <<i);
Rslt = inA &AgB;
AgB = ~AgB;
Rslt |= (inB &AgB);
//——————–
return Rslt;
} //Compar
ایده کاملا صحیح و پیاده سازی هم اوکی هست -از اونجایی که حلقه رو توی برنامه میشه با معادل جایگزین کرد پس مشکلی نداره
برنامه تست شما : https://pastecode.xyz/view/b2451ac7
با سلام و احترام
لطفا کد زیر رو جایگزین کنید که حلقه هم نداشته باشه، ممنون :))
//—————- WORD_BYTES 16-bit
typedef union _WORD_BYTES {
WORD word;
BYTE bytes[2];
struct {
BYTE LB;
BYTE HB;
} byte;
struct {
unsigned char bit0:1;
unsigned char bit1:1;
unsigned char bit2:1;
unsigned char bit3:1;
unsigned char bit4:1;
unsigned char bit5:1;
unsigned char bit6:1;
unsigned char bit7:1;
unsigned char bit8:1;
unsigned char bit9:1;
unsigned char bit10:1;
unsigned char bit11:1;
unsigned char bit12:1;
unsigned char bit13:1;
unsigned char bit14:1;
unsigned char bit15:1;
} bits;
} WORD_BYTES;
unsigned int zMax(unsigned int inA, unsigned int inB)
{
unsigned char AcaB, AcoB;
unsigned int Bnt;
WORD_BYTES ABnt, AxnB;
unsigned int Rslt[2];
//——————–
Rslt[1] = inA;
Rslt[0] = inB;
Bnt = ~inB;
ABnt.word = inA &Bnt;
AxnB.word = ~(inA ^inB);
//——————–
AcoB = ABnt.bits.bit15;
AcaB = AxnB.bits.bit15;
AcoB |= (ABnt.bits.bit14 &AcaB);
AcaB &= AxnB.bits.bit14;
AcoB |= (ABnt.bits.bit13 &AcaB);
AcaB &= AxnB.bits.bit13;
AcoB |= (ABnt.bits.bit12 &AcaB);
AcaB &= AxnB.bits.bit12;
AcoB |= (ABnt.bits.bit11 &AcaB);
AcaB &= AxnB.bits.bit11;
AcoB |= (ABnt.bits.bit10 &AcaB);
AcaB &= AxnB.bits.bit10;
AcoB |= (ABnt.bits.bit9 &AcaB);
AcaB &= AxnB.bits.bit9;
AcoB |= (ABnt.bits.bit8 &AcaB);
AcaB &= AxnB.bits.bit8;
AcoB |= (ABnt.bits.bit7 &AcaB);
AcaB &= AxnB.bits.bit7;
AcoB |= (ABnt.bits.bit6 &AcaB);
AcaB &= AxnB.bits.bit6;
AcoB |= (ABnt.bits.bit5 &AcaB);
AcaB &= AxnB.bits.bit5;
AcoB |= (ABnt.bits.bit4 &AcaB);
AcaB &= AxnB.bits.bit4;
AcoB |= (ABnt.bits.bit3 &AcaB);
AcaB &= AxnB.bits.bit3;
AcoB |= (ABnt.bits.bit2 &AcaB);
AcaB &= AxnB.bits.bit2;
AcoB |= (ABnt.bits.bit1 &AcaB);
AcaB &= AxnB.bits.bit1;
AcoB |= (ABnt.bits.bit0 &AcaB);
//——————–
return Rslt[AcoB];
} //zMax
ضمنا، اگر امکانش هست، بهینه ترین کد از نظر حجم و سرعت رو هم معرفی کنید
شهرام خان اون حلقه اوکیه ! مشکلی نداه
هنوز تو فاز چک کردن پاسخ های دوستان هستم انشالله اون که تمام بشه میریم به سراغ بهترین جواب احتمالا
سلام و خسته نباشید به طراح مسابقه و همه سیسوگیا
فرض کنید دو متغیر صحیح داریم، اگر از بیت پر ارزش به سمت بیت کم ارزش حرکت کنیم، متغیری بزرگتر هست که در اولین اختلافشون دارای بیت 1 است. دو مثال زیر این رو نشون میده:
http://s6.picofile.com/file/8391145934/step.png
بیتی که داخل پرانتز گذاشته شده، اولین بیتی هست که در دو عدد اختلاف ایجاد شده، در قسمت دوم که دو عدد با هم xor شدن، معادل اولین بیت 1 خواهد بود. قسمت سوم، حاصل قسمت دوم با اعداد اصلی & میشود. در این مرحله بیتی داخل پرانتز نشان دهنده عدد بزرگتر است. هدف ما در مرحله چهار، پیدا کردن این بیت و بسط دادن اون تا کم ارزش ترین بیت است.
در مرحله4 بیت های پرارزش تر از بیتی که با پرانتز علامت دار شده باید صفر باشند، چون هر دو عدد در این بیتها یکسان هستند.
درنهایت مقدار ماکسیمم و مینیمم از روابط زیر بدست خواهد آمد.
minVal = (a & bFlag) | (b & ~bFlag);
maxVal = (a & aFlag) | (b & ~aFlag);
در هر دو متغیر کمکی، همانطور که گفته شد، بیتهای پرارزش برابر صفر هستند. بنابراین در هر دو رابطه بالا، مقادیر این بیتها از متغیر دوم اخذ میگردد (فرقی نمیکند).
کد نوشته شده به صورت زیر است
http://s6.picofile.com/file/8391142326/CompareWithLogic.png
با اجرای کد نتیجه به صورت زیر خواهد بود
http://s6.picofile.com/file/8391142334/Result.PNG
اما توضیح کد:
تو این کد فقط از عملگرهای بیتی ~، |، &، ^ و <> 1) | (c & (~(bFlag >> 1)));
bFlag |= (bFlag >> 1) | (d & (~(aFlag >> 1)));
این دو رابطه به منظور پیاده سازی مرحله 4 در تصویر اول است. قسمت اول به این منظور است که هر متغیر در صورتی که بیت آن در مرحله قبل 1 شده باشد، سایر بیتهای آن نیز برابر با 1 گردد. قسمت دوم نیز برای این است که در صورت مشاهده اختلاف بیت متغیر کمکی متناظر با متغیر اصلی که بیت آن برابر با 1 شده، 1 گردد؛ و بخش دوم آن برای بررسی این است که متغیر متقابل آن در مرحله قبل 1 نشده باشد.
سلام و درود
خوب برنامه شما هم به خوبی کار کرد – ولی روش سختی رو برای پیاده سازیش در نظر گرفتید 🙂
کد تست شما : https://pastecode.xyz/view/363c5248
#include
// Subtraction two numbers without using the ‘-‘ operator
int subtract(int x, int y)
{
while (y)
{
int borrow = (~x) & y;
x = x ^ y;
y = borrow « 1;
}
return x;
}
int Max(int x, int y)
{
// sizeof(int) = 4 byte =====> 4*8 = 32
// return x – ((x – y) & ((x – y) » (sizeof(int) * 8 – 1)));
// return x – ((x – y) & ((x – y) » (32 – 1)));
return subtract(x,(subtract(x,y) & (subtract(x,y) » subtract(32,1))));
}
int main()
{
int x,y;
printf (“Please enter a : “);
scanf(“%d”,&x);
printf (“Please enter b : “);
scanf(“%d”,&y);
printf(“Max is %d”, Max(x, y));
return 0;
}
سلام
هم از ضرب و هم منهی و هم شرط درون بدنه حلقه استفاده کردید !!! که ناقض شرایط مسابقه هستن
سلام 2 تا سوال
1- از ساختار swith میشه استفاده کرد؟ (منوط به اینکه از ساختار های شرطی ,==,=,&&,||,!,!= در آن استفاده نشود)
2- از حلقه for میشه استفاده کرد؟ چون توی حلقه for باید برای افزایش یا کاهش index از ++ یا — استفاده کرد که خودش یه نوع جمع یا تفریق حساب میشه 🙂
سلام
۱ سوییچ هم جزو ساختار شرطی است
۲ پس جواب خودتون رو دادید دیگه شرطه !
حتی while هم چون شرط داره نمیشه استفاده کرد توی پست نوشتم هرگونه ساختار شرطی حتی در مورد حلقه ها
ممنون از پاسختون در مورد عملگر % یادم رفت بپرسم آیا مجاز هست؟
خواهش میکنم مشکلی نداره از باقی مانده استفاده کنید.
#include
// Subtraction two numbers without using the ‘-‘ operator
int subtract(int x, int y)
{
// Iterate till there
// is no carry
while (y)
{
// borrow contains common
// set bits of y and unset
// bits of x
int borrow = (~x) & y;
// Subtraction of bits of x
// and y where at least one
// of the bits is not set
x = x ^ y;
// Borrow is shifted by one
// so that subtracting it from
// x gives the required sum
y = borrow <> (sizeof(int) * 8 – 1)));
// sizeof(int) = 4 byte =====> 4*8 = 32
return subtract(x,(subtract(x,y) & (subtract(x,y) >> subtract(32,1))));
}
int main()
{
int x,y;
printf (“Please enter a : “);
scanf(“%d”,&x);
printf (“Please enter b : “);
scanf(“%d”,&y);
printf(“Max is %d”, Max(x, y));
return 0;
}
من توی برنامه شما تابع max نمی بینم که ازش استفاده کردید ؟
در ضمن توی تابع subtract از شرط داخل وایل استفاده کردید که ناقض شرایط مسابقه است
scanf(“%d%d”,&a,&b);printf(“%+ld”,0l+a-b);
جمع و منهی شرایط مسابقه رو نقض کرده.
از دستور ++ هم نمیشه استفاده کرد ؟؟
++ هم منطقا غیر مجازه دیگه
سلام
جوابها رو فعلا قرار نمیدهید؟
اخه جواب من‌نیست ،ثبت نشده یا بعد از پایان زمان قرار میگیره؟
جواب ها تا پایان مهلت مسابقه منطقا نباید منتشر شوند دیگه – ولی سوال دوستان رو که ممکنه شکی رو برطرف کنه رو جواب میدم
منظورتون اینه که ساختار شرطی رو با استفاده از or , xor, and , shift بیتی بنویسیم؟
بله به دلیل این که جواب این کامنت راهنمایی حساب میشد تایید نشد.
سلام من برنامه نویسی به سبک ناسا رو چند روز پیش ازتون خریدم ، می‌گفتید نخرم دیگه خخخخخ
من جواب مسابقه رو بدم جایزه اش فرقی نمیکنه؟؟
سلام شما برنده باشید حتما باهاتون یه توافق جدید میکنیم :-))
اگر از | و & و ^ نشه استفاده کرد که نمیشه خود کامپیوتر هم با همین گیت های نور و اند کار میکنه !!!
لطفا جواب من رو بدهید من از ساعت 5 صبح نشستم دارم می نویسم.
سلام چرا نمیشه از اینا استفاده کرد ؟ میشه !
چیزی که مجاز نیست رو نوشتم توی پست && با & فرق داره توی زبان سی !!
به نظر من، سوال فوق، هرچند ادعای نرم‌افزاری داشت، ولی خیلی سخت‌افزاری بود. اینکار دقیقا شبیه کار با پردازنده‌ای بود که ALU آن تنها گیت‌های منطقی and و not و or و xor را داشته باشد. بنابراین باید همه‌ی توابع را با استفاده از این عملگرها می‌نوشتیم.
خود من از طراحی جمع‌کننده‌ی چند بیتی ایده گرفتم برای این برنامه. شاید هم من پیچیده فکر کرده ام!!!
خوب تلفیق نرم افزار و سخت افزار و البته باید چیزی می بود که با سرچ ساده کد به دست نیاد برای همین مجبور بودم این شرایط رو بذارم.
سلام. فکر کنم توضیحات لازم را در کامنت‌های کد داده‌ام. اگر توضیحات ناقص بود، بگویید بیشتر توضیح دهم.
bool g(bool a, bool b) //g(a,b)= 1 if a is greater than b (a and b are two bits)
{return a&(~b);}
bool e(bool a, bool b) //e(a,b)= 1 if a equals b (a and b are two bits)
{return(~(a^b) & 0x0001);}
uint16_t max(int x, int y)
{
//seperating the bits of x and y
bool x0 = x & 1, y0 = y & 1;
bool x1 = x & 2, y1 = y & 2;
bool x2 = x & 4, y2 = y & 4;
bool x3 = x & 8, y3 = y & 8;
bool x4 = x & 16, y4 = y & 16;
bool x5 = x & 32, y5 = y & 32;
bool x6 = x & 64, y6 = y & 64;
bool x7 = x & 128, y7 = y & 128;
bool x8 = x & 256, y8 = y & 256;
bool x9 = x & 512, y9 = y & 512;
bool x10 = x & 1024, y10 = y & 1024;
bool x11 = x & 2048, y11 = y & 2048;
bool x12 = x & 4096, y12 = y & 4096;
bool x13 = x & 8192, y13 = y & 8192;
bool x14 = x & 16384, y14 = y & 16384;
bool x15 = x & 32768, y15 = y & 32768;
//If x>y, either x0>y0, or they’re equal but x1>y1 and so on
bool b1 = g(x15,y15);
bool b2 = e(x15,y15)&g(x14,y14);
bool b3 = e(x15,y15)&e(x14,y14)&g(x13,y13);
bool b4 = e(x15,y15)&e(x14,y14)&e(x13,y13)&g(x12,y12);
bool b5 = e(x15,y15)&e(x14,y14)&e(x13,y13)&e(x12,y12)&g(x11,y11);
bool b6 = e(x15,y15)&e(x14,y14)&e(x13,y13)&e(x12,y12)&e(x11,y11)&g(x10,y10);
bool b7 = e(x15,y15)&e(x14,y14)&e(x13,y13)&e(x12,y12)&e(x11,y11)&e(x10,y10)&g(x9,y9);
bool b8 = e(x15,y15)&e(x14,y14)&e(x13,y13)&e(x12,y12)&e(x11,y11)&e(x10,y10)&e(x9,y9)&g(x8,y8);
bool b9 = e(x15,y15)&e(x14,y14)&e(x13,y13)&e(x12,y12)&e(x11,y11)&e(x10,y10)&e(x9,y9)&e(x8,y8)&g(x7,y7);
bool b10 = e(x15,y15)&e(x14,y14)&e(x13,y13)&e(x12,y12)&e(x11,y11)&e(x10,y10)&e(x9,y9)&e(x8,y8)&e(x7,y7)&g(x6,y6);
bool b11 = e(x15,y15)&e(x14,y14)&e(x13,y13)&e(x12,y12)&e(x11,y11)&e(x10,y10)&e(x9,y9)&e(x8,y8)&e(x7,y7)&e(x6,y6)&g(x5,y5);
bool b12 = e(x15,y15)&e(x14,y14)&e(x13,y13)&e(x12,y12)&e(x11,y11)&e(x10,y10)&e(x9,y9)&e(x8,y8)&e(x7,y7)&e(x6,y6)&e(x5,y5)&g(x4,y4);
bool b13 = e(x15,y15)&e(x14,y14)&e(x13,y13)&e(x12,y12)&e(x11,y11)&e(x10,y10)&e(x9,y9)&e(x8,y8)&e(x7,y7)&e(x6,y6)&e(x5,y5)&e(x4,y4)&g(x3,y3);
bool b14 = e(x15,y15)&e(x14,y14)&e(x13,y13)&e(x12,y12)&e(x11,y11)&e(x10,y10)&e(x9,y9)&e(x8,y8)&e(x7,y7)&e(x6,y6)&e(x5,y5)&e(x4,y4)&e(x3,y3)&g(x2,y2);
bool b15 = e(x15,y15)&e(x14,y14)&e(x13,y13)&e(x12,y12)&e(x11,y11)&e(x10,y10)&e(x9,y9)&e(x8,y8)&e(x7,y7)&e(x6,y6)&e(x5,y5)&e(x4,y4)&e(x3,y3)&e(x2,y2)&g(x1,y1);
bool b16 = e(x15,y15)&e(x14,y14)&e(x13,y13)&e(x12,y12)&e(x11,y11)&e(x10,y10)&e(x9,y9)&e(x8,y8)&e(x7,y7)&e(x6,y6)&e(x5,y5)&e(x4,y4)&e(x3,y3)&e(x2,y2)&e(x1,y1)&g(x0,y0);
bool x_is_g = b1 | b2 | b3 | b4 | b5 | b6 | b7 | b8 | b9 | b10 | b11 | b12 | b13 | b14 | b15 | b16;
int x_is_greater = x_is_g | (x_is_g<<1) | (x_is_g<<2) | (x_is_g<<3) |
(x_is_g<<4) | (x_is_g<<5) | (x_is_g<<6) | (x_is_g<<7) |
(x_is_g<<8) | (x_is_g<<9) | (x_is_g<<10) | (x_is_g<<11) |
(x_is_g<<12)| (x_is_g<<13) | (x_is_g<<14) | (x_is_g<<15); //this variable will be either 0 or 0xFFFF
return ((x_is_greater & x) | ((~x_is_greater)&y)); //if x_is_greater is 0, then y will be returned, otherwise it's 0xFFFF and x will be returned
}
بسیار عالی برنامه شما هم به خوبی کار میکنه و شرایط مسابقه هم رعایت شده
برنامه تست تابع شما : https://pastecode.xyz/view/1ef5c7f3
علامت انتساب = هم قبول نیست واقعا دیگه دارم کم میارم..
انصاب یعنی = مشکلی نداره ، دابل == مشکل داره
اگر فقط از ^ & | شیفت استفاده شود چی؟
مشکلی نداره این عمل وند ها
حتی & | ! منطقی هم قبول نیست؟
تنها ‘!’ قبول نیست!
باقیه مشکلی نداره
سلام
اولین روشی که به ذهنم رسید به این صورت که:
به ترتیب از پر ارزش ترین تا کم ارزش ترین بیت های دو عدد با هم مقایسه شوند و به محض پیدا شدن اولین بیت هم ارزش در ۲ عدد که با هم یکسان نیستن،عددی بزرگتر است که بیت آن دارای مقدار یک است.
برای این کار بدون استفاده از دستور شرطی میتونیم برنامه را بصورت زیر بنویسیم.
برای جداسازی و مقایسه بیت های با ارزش یکسان دو عدد ابتدا هر کدام از اعداد را با مقدار متناظر آن بیت & میکنیم تا مقدار آن بیت بدست آید ، سپس برای مقایسه با مقدار بیت متناظر در عدد دیگر ، آنها را با هم xor میکنیم تا در صورت برابر نبودن مقدار بیت های متناظر ، عددی که دارای بیت با ارزش یک است را به عنوان عدد بزرگتر باز گرداند
این چک کردن باید تا پیدا شدن اولین بیت نا برابر با بیت متناظر خود در عدد دیگر ادامه پیدا کند و اگر تا کم ارزش ترین بیت چک شد و تمام بیت ها با هم برابر بودن نتیجه میگیریم که دو عدد با هم برابر هستن و یکی از اعداد را به عنوان عدد بزرگتر برمیگردانیم.
uint16_t Max(uint16_t First,uint16_t Second)
{
while( (First & 0x8000) ^ (Second & 0x8000) )
{
while(First & 0x8000)
return First;
return Second;
}
while( (First & 0x4000) ^ (Second & 0x4000) )
{
while(First & 0x4000)
return First;
return Second;
}
while( (First & 0x2000) ^ (Second & 0x2000) )
{
while(First & 0x2000)
return First;
return Second;
}
while( (First & 0x1000) ^ (Second & 0x1000) )
{
while(First & 0x1000)
return First;
return Second;
}
while( (First & 0x0800) ^ (Second & 0x0800) )
{
while(First & 0x0800)
return First;
return Second;
}
while( (First & 0x0400) ^ (Second & 0x0400) )
{
while(First & 0x0400)
return First;
return Second;
}
while( (First & 0x0200) ^ (Second & 0x0200) )
{
while(First & 0x0200)
return First;
return Second;
}
while( (First & 0x0100) ^ (Second & 0x0100) )
{
while(First & 0x0100)
return First;
return Second;
}
while( (First & 0x0080) ^ (Second & 0x0080) )
{
while(First & 0x0080)
return First;
return Second;
}
while( (First & 0x0040) ^ (Second & 0x0040) )
{
while(First & 0x0040)
return First;
return Second;
}
while( (First & 0x0020) ^ (Second & 0x0020) )
{
while(First & 0x0020)
return First;
return Second;
}
while( (First & 0x0010) ^ (Second & 0x0010) )
{
while(First & 0x0010)
return First;
return Second;
}
while( (First & 0x0008) ^ (Second & 0x0008) )
{
while(First & 0x0008)
return First;
return Second;
}
while( (First & 0x0004) ^ (Second & 0x0004) )
{
while(First & 0x0004)
return First;
return Second;
}
while( (First & 0x0002) ^ (Second & 0x0002) )
{
while(First & 0x0002)
return First;
return Second;
}
while( (First & 0x0001) ^ (Second & 0x0001) )
{
while(First & 0x0001)
return First;
return Second;
}
return First;
}
فقط عملگرهای شرطی(== != =) غیر مجازه یا استفاده از خود دستور if هم غیر مجازه؟
= یا انتصاب مجازه ولی باقیه غیر مجازه خود if هم که جزو ساختار شرطی هست دیگه غیر مجازه
منطق درستی داره برنامه تون ولی اولین شرط مسابقه رو نقض میکنه
نباید از هیچ گونه ساختار شرطی استفاده شود ( <,>,==,<=,>=,&&,||,!,!= ) {حتی شرط‌های درون بدنه حلقه}
حتی شرط های درون بدنه حلقه
int LN(int a,int b)
{
int c=a-b;
int k=(c>>31)&1;
return (a-k*c)
}
سلام – خوب شما چرا از منهی و ضرب استفاده کردید
اینا شرایط مسابقه رو نقض میکنه !
#include
#include
#include
uint16_t A=5000;//first number
uint16_t B=4995;//second number
uint16_t K;//for disabling the MSB bit of both number until reach 1 . if it’s 0 then both number is equal.
uint16_t Z;//remove the MSB compared bit of A
uint16_t W;//remove the MSB compared bit of B
uint16_t M;//Buffer for Lshifting number. OLD SCHOOL MODE ;D
uint16_t N;//Buffer for Lshifting number. OLD SCHOOL MODE ;D
int main()
{
K=A^B; // XOR BOTH NUMBER FOR REMOVING THE EQUAL BIT.
Z=(A&K);//THE BIGGER BINARY NUMBER HAS GREATER INDEX OF HIGH BIT THAT EQUAL TO 1.
W=(B&K);//THE BIGGER BINARY NUMBER HAS GREATER INDEX OF HIGH BIT THAT EQUAL TO 1.
for(uint8_t i=0;i<16;i++)
{
M=((Z<<i))&0x8000;//SHIFTING THE BIT TO LEFT ONE BY ONE SO THE FIRST ONEQUAL BIT THE REPRESENTED 1 MUST BE THE HIGHER NUMBER VALUE.
N=((W<<i))&0x8000;//SHIFTING THE BIT TO LEFT ONE BY ONE SO THE FIRST ONEQUAL BIT THE REPRESENTED 1 MUST BE THE HIGHER NUMBER VALUE.
while(M)//IF THE FIRST NUMBER REACHES BIT VALUE 1 IN SHIFTING PROCESS.
{
printf("NUMBER A is bigger");
return 0;
}
while(N)//IF THE SECOND NUMBER REACHES BIT VALUE 1 IN SHIFTING PROCESS.
{
printf("NUMBER B is bigger");
return 0;
}
while(!K)//IF BOTH NUMBER IS EQUAL THEN XOR WOULD BE ZERO.
{
printf("Both Number is equal");
return 0;
}
}
}
خوب پیش رفتید ولی برای انتخاب عدد بزرگتر از شرط موجود در while استفاده کردید که توی شرایط مسابقه بود که غیرمجازه
while(M)//IF THE FIRST NUMBER REACHES BIT VALUE 1 IN SHIFTING PROCESS.
{
printf("NUMBER A is bigger");
return 0;
}
اینجا رو میگم
پاسخ رو در قالب پروژه code blocks براتون ایمیل میکنم !!!
به کدام ایمیل ارسال کردید ؟
Hello
The first part is a simple comparator circuit simulated in C. This part sets the flag “a_is_largest”. second part makes a “base” value out of this flag then generates the output and returns. here is the link:
https://drive.google.com/file/d/1M_ddaMvrXfo55pMsBhk7n_khaibsj6Kf/view
(salam, keyboard farsi nadaram)
کاملا درسته و برنامه شما به خوبی کار میکنه 🙂
برنامه تست برنامه شما : https://pastecode.xyz/view/0605617f
سلام مرسی فقط من اسمم محمده 🙂
جواب کاملا ساده است
دوتا آرگومان دریافتی از نوع 16 بیتی دریافت میکنیم دو عدد را xor میکنیم سپس جواب بدست آمده را not میکنیم به ابن ترتیب جواب بدست آمده مقدار عدد بزرگتر تر است و آن را برمیگردانیم.
نه خوب به این سادگی هم نیست – اون موقع باید یه فکری هم به حال بیت علامت بکنید !!
int main()
{
short x;
short y;
short r;
scanf(“%d”,&x);
scanf(“%d”,&y);
r = x ^ ((x ^ y) & -(x < y));
printf("%d",r);
return 0;
}
سلام
خوب الان شما در این برنامه شرایط مسابقه رو رعایت نکردید اون منفی که استفاده کردید و علامت > کار رو خراب کرده.
a * (bool)(a / b) + b * (bool)(b / a)
سلاام
خوب این جزور پیشنهاد های خودمونه که گفتیم با سرچ میتونید پیدا کنید و قبول نیست !
تازه جزو شرط های مسابقه این بوده که از جمع و منهی و ضرب و تقسیم استفاده نکنیم
و اینکه بنده کد زیر را در نرم افزار کدبلاک تست کردم و به خوبی کار کردش
;int a , b
<include b ? a : b#
()int main
}
;int out = 0
;(out = sisoog (10,100
(printf (“%d “, out
{
بله درسته کار میکنه به خوبی هم کار میکنه ولی خوب ظرایط مسابقه رو رعایت نکرده
لطفاً این مطلب رو تو کانالم آپدیت کنید
با سلام تابع نوشته شده به صورت زیر است:
uint16_t findMax(uint16_t x, uint16_t y)
{
uint16_t z=(x<y);
//uint16_t z=comp(x,y);
z=z|z<<1|z<<2|z<<3|z<<4|z<<5|z<<6|z<<7|z<<8|z<<9|z<<10|z<<11|z<<12|z<<13|z<<14|z< نیز ممنوع باشد کافی است خط زیری آن را از کامنت در بیاوریم و از تابع زیر استفاده کنیم:
bool comp(uint16_t x, uint16_t y) // returns y>x
{
bool x_bits[16]={x,x>>1,x>>2,x>>3,x>>4,x>>5,x>>6,x>>7,
x>>8,x>>9,x>>10,x>>11,x>>12,x>>13,x>>14,x>>15};
bool y_bits[16]={y,y>>1,y>>2,y>>3,y>>4,y>>5,y>>6,y>>7,
y>>8,y>>9,y>>10,y>>11,y>>12,y>>13,y>>14,y>>15};
return ( y_bits[15]&&!x_bits[15] ||
y_bits[14]&&!x_bits[14] && !(y_bits[15] ^ x_bits[15]) ||
y_bits[13]&&!x_bits[13] && !(y_bits[15] ^ x_bits[15]) && !(y_bits[14] ^ x_bits[14])||
y_bits[12]&&!x_bits[12] && !(y_bits[15] ^ x_bits[15])&& !(y_bits[14] ^ x_bits[14])&& !(y_bits[13] ^ x_bits[13])||
y_bits[11]&&!x_bits[11] && !(y_bits[15] ^ x_bits[15])&& !(y_bits[14] ^ x_bits[14])&& !(y_bits[13] ^ x_bits[13])&& !(y_bits[12] ^ x_bits[12])||
y_bits[10]&&!x_bits[10] && !(y_bits[15] ^ x_bits[15])&& !(y_bits[14] ^ x_bits[14])&& !(y_bits[13] ^ x_bits[13])&& !(y_bits[12] ^ x_bits[12])&& !(y_bits[11] ^ x_bits[11])||
y_bits[9]&&!x_bits[9] && !(y_bits[15] ^ x_bits[15])&& !(y_bits[14] ^ x_bits[14])&& !(y_bits[13] ^ x_bits[13])&& !(y_bits[12] ^ x_bits[12])&& !(y_bits[11] ^ x_bits[11])&& !(y_bits[10] ^ x_bits[10])||
y_bits[8]&&!x_bits[8] && !(y_bits[15] ^ x_bits[15])&& !(y_bits[14] ^ x_bits[14])&& !(y_bits[13] ^ x_bits[13])&& !(y_bits[12] ^ x_bits[12])&& !(y_bits[11] ^ x_bits[11])&& !(y_bits[10] ^ x_bits[10])&& !(y_bits[9] ^ x_bits[9])||
y_bits[7]&&!x_bits[7] && !(y_bits[15] ^ x_bits[15])&& !(y_bits[14] ^ x_bits[14])&& !(y_bits[13] ^ x_bits[13])&& !(y_bits[12] ^ x_bits[12])&& !(y_bits[11] ^ x_bits[11])&& !(y_bits[10] ^ x_bits[10])&& !(y_bits[9] ^ x_bits[9])&& !(y_bits[8] ^ x_bits[8])||
y_bits[6]&&!x_bits[6] && !(y_bits[15] ^ x_bits[15])&& !(y_bits[14] ^ x_bits[14])&& !(y_bits[13] ^ x_bits[13])&& !(y_bits[12] ^ x_bits[12])&& !(y_bits[11] ^ x_bits[11])&& !(y_bits[10] ^ x_bits[10])&& !(y_bits[9] ^ x_bits[9])&& !(y_bits[8] ^ x_bits[8])&& !(y_bits[7] ^ x_bits[7])||
y_bits[5]&&!x_bits[5] && !(y_bits[15] ^ x_bits[15])&& !(y_bits[14] ^ x_bits[14])&& !(y_bits[13] ^ x_bits[13])&& !(y_bits[12] ^ x_bits[12])&& !(y_bits[11] ^ x_bits[11])&& !(y_bits[10] ^ x_bits[10])&& !(y_bits[9] ^ x_bits[9])&& !(y_bits[8] ^ x_bits[8])&& !(y_bits[7] ^ x_bits[7]) && !(y_bits[6] ^ x_bits[6]) ||
y_bits[4]&&!x_bits[4] && !(y_bits[15] ^ x_bits[15])&& !(y_bits[14] ^ x_bits[14])&& !(y_bits[13] ^ x_bits[13])&& !(y_bits[12] ^ x_bits[12])&& !(y_bits[11] ^ x_bits[11])&& !(y_bits[10] ^ x_bits[10])&& !(y_bits[9] ^ x_bits[9])&& !(y_bits[8] ^ x_bits[8])&& !(y_bits[7] ^ x_bits[7]) && !(y_bits[6] ^ x_bits[6]) && !(y_bits[5] ^ x_bits[5])||
y_bits[3]&&!x_bits[3] && !(y_bits[15] ^ x_bits[15])&& !(y_bits[14] ^ x_bits[14])&& !(y_bits[13] ^ x_bits[13])&& !(y_bits[12] ^ x_bits[12])&& !(y_bits[11] ^ x_bits[11])&& !(y_bits[10] ^ x_bits[10])&& !(y_bits[9] ^ x_bits[9])&& !(y_bits[8] ^ x_bits[8])&& !(y_bits[7] ^ x_bits[7]) && !(y_bits[6] ^ x_bits[6]) && !(y_bits[5] ^ x_bits[5])&& !(y_bits[4] ^ x_bits[4])||
y_bits[2]&&!x_bits[2] && !(y_bits[15] ^ x_bits[15])&& !(y_bits[14] ^ x_bits[14])&& !(y_bits[13] ^ x_bits[13])&& !(y_bits[12] ^ x_bits[12])&& !(y_bits[11] ^ x_bits[11])&& !(y_bits[10] ^ x_bits[10])&& !(y_bits[9] ^ x_bits[9])&& !(y_bits[8] ^ x_bits[8])&& !(y_bits[7] ^ x_bits[7]) && !(y_bits[6] ^ x_bits[6]) && !(y_bits[5] ^ x_bits[5])&& !(y_bits[4] ^ x_bits[4])&& !(y_bits[3] ^ x_bits[3])||
y_bits[1]&&!x_bits[1] && !(y_bits[15] ^ x_bits[15])&& !(y_bits[14] ^ x_bits[14])&& !(y_bits[13] ^ x_bits[13])&& !(y_bits[12] ^ x_bits[12])&& !(y_bits[11] ^ x_bits[11])&& !(y_bits[10] ^ x_bits[10])&& !(y_bits[9] ^ x_bits[9])&& !(y_bits[8] ^ x_bits[8])&& !(y_bits[7] ^ x_bits[7]) && !(y_bits[6] ^ x_bits[6]) && !(y_bits[5] ^ x_bits[5])&& !(y_bits[4] ^ x_bits[4])&& !(y_bits[3] ^ x_bits[3])&& !(y_bits[2] ^ x_bits[2])||
y_bits[0]&&!x_bits[0] && !(y_bits[15] ^ x_bits[15])&& !(y_bits[14] ^ x_bits[14])&& !(y_bits[13] ^ x_bits[13])&& !(y_bits[12] ^ x_bits[12])&& !(y_bits[11] ^ x_bits[11])&& !(y_bits[10] ^ x_bits[10])&& !(y_bits[9] ^ x_bits[9])&& !(y_bits[8] ^ x_bits[8])&& !(y_bits[7] ^ x_bits[7]) && !(y_bits[6] ^ x_bits[6]) && !(y_bits[5] ^ x_bits[5])&& !(y_bits[4] ^ x_bits[4])&& !(y_bits[3] ^ x_bits[3])&& !(y_bits[2] ^ x_bits[2])&& !(y_bits[1] ^ x_bits[1])
);
}
همانطور که مشخص است در تابع comp تلاش شده است تا عملگر مقایسه 2 عدد باینری 16 بیتی دقیقا مانند آنچه در سخت افزار اتفاق می افتد انجام شود به این گونه که از پر ارزش ترین بیت شروع می کنیم و تا جایی پیش می رویم که بیت y یک شود و معادل x آن 0 شود (و بیت های قبل آن مساوی باشند) اگر این اتفاق رخ داد پس y>x در غیر اینصورت x<=y است.
پس تا به اینجای کار ما می دانیم که x با y کدام بزرگتر است پس کافی است خروجی تابع comp را به اندازه 16 بیت pad کنیم و در متغییر z بریزیم اکنون یا در z 16 تا 1 است یا 16 0 و با کمک این ماسک مشخص می کنیم که متغیر x با چه باید xor شود اگر 0 باشد پس x بزرگتر است و با xor آن با 0 به x می رسیم و اگر 1 باشد پس خروجی xor شده ی x^y با x می شود با توجه به اینکه تابع xor معکوس خودش است پس جواب برابر است با y.
خوب ایده ای که داشتید درسته ولی چرا به جای استفاده از & از && استفاده کردید ؟ فرض کتیم تابع comp هم درست کار میکنه و نوشتارش قابل قبول باشه خوب خروجی اون bool هست یعنی در تعریف عدد یا 0 یا FF هست چطور بعد از کست اون به uint16_t به عدد بزرگتر رسیدید ؟
از توضیحات متوجه نشدم
با سلام بنده در 3 ورژن مختلف جواب سوال را اصلاح کردم ودر آخرین ورژن همه ی && ها را با & و || ها را با | جایگزین کردم (چون استفاده از && و.. ممنوع بود) و بنده فقط قصد محاسبه یک بیت رو داشتم برای یک عدد 1 بیتی هم می توان این 2 رو معادل در نظر گرفت و اینکه خود تابع findmax ظاهرا خط آخرش جا افتاده است که در آخرین ویرایش پاسخ اگر بررسی کنید به این صورت نوشته شده است:
uint16_t findMax(uint16_t x, uint16_t y)
{
uint16_t z=(x<y);
//uint16_t z=comp(x,y);
z=z|z<<1|z<<2|z<<3|z<<4|z<<5|z<<6|z<<7|z<<8|z<<9|z<<10|z<<11|z<<12|z<<13|z<<14|z<<15;
return x^((y^x)&z);
}
یعنی با توجه به کوچک بودن و بزرگ بودن این 2 یا خود x بر می گردد یا y که 2 بار با x xor شده است ( در نهایتy )
با تشکر
سلام کد شما رو بررسی کردم : https://onlinegdb.com/HJ-ofiNUU
برای ورودی های زیر خروجی مناسبی نداشت – خودتون هم بررسی کنید
A=2,B=3 Max=2
A=4,B=5 Max=4
A=4,B=6 Max=4
A=4,B=7 Max=4
A=5,B=6 Max=5
با سلام خیلی ممنون از وقتی که گذاشتید بله متوجه اشتباهم شدم
مشکل توی جدا کردن بیت ها بود این 2 خط رو دست کردم درست شد
bool x_bits[16]={x&(1<<0),x& (1<<1),x&(1<<2),x&(1<<3),x&(1<<4),x&(1<<5),x&(1<<6),x&(1<<7),
x&(1<<8),x&(1<<9),x&(1<<10),x&(1<<11),x&(1<<12),x&(1<<13),x&(1<<14),x&(1<<15)};
bool y_bits[16]={y&(1<<0),y& (1<<1),y&(1<<2),y&(1<<3),y&(1<<4),y&(1<<5),y&(1<<6),y&(1<<7),
y&(1<<8),y&(1<<9),y&(1<<10),y&(1<<11),y&(1<<12),y&(1<<13),y&(1<<14),y&(1<<15)};
خیلی ممنون 🙂
خیلی عالی :)))
سلام این تابع را نوشتم و درست کار کرد فکر کنم شرایط مورد نظر رعایت شده باشه
نحوه کار خیلی سادس با توجه با عملگر بزرگتر و کوچکتر و حلقه
For یک عدد 0
xFFFF برای عدد بزرگتر و عدد صفر برای کوچکتره ساخته و با اون and میشه و در نهایت دو عدد حاصا OR میشوند که نتیجه عدد بزرگتر هست
uint16_t getMax(uint16_t x , uint16_t y)
{
uint16_t a=(uint8_t) (x>y);
uint16_t b=(uint8_t) (x<y);
for(uint8_t i=0 ; i<15 ; i++) a|= a<<i ;
for(uint8_t i=0 ; i<15 ; i++) b|= b<<i ;
return (a&x) | (b&y);
}
خوب استفاده از < و > که مجاز نبود ! گفتیم استفاده به هر شکل مشکل داره
سلام این تابع را نوشتم و تست شده درست کار کرد فکر کنم شرایط مورد نظر رعایت شده باشه
نحوه کار خیلی سادس با توجه با عملگر > و y);
uint16_t b=(uint8_t) (x<y);
for(uint8_t i=0 ; i<15 ; i++) a|= a<<i ;
for(uint8_t i=0 ; i<15 ; i++) b|= b<<i ;
return (a&x) | (b&y);
}
خوب الان این برنامه شما رو من چطور تست کنم
الان متغییر های x,y چی هستن و از کجا اومدن ؟ متغییر های a و b چطور ؟
اگر فرض کنیم x,y ورودی ها باشند چرا از مقایسه توی بدنه برنامه استفاده کردید ؟
من فکر کنم با عملیات باقیمانده تقسیم میشه x%y و حاصل رو ،cast کنیم به ، uijt16
البته مستقیما تقسیم نکردیم ….
اگر عدد بزرگ رو تقسیم بر عدد کوچک کنیم چون حاصر از یک بزرگتر میشه مقدار یک بر میگردونه و اگر عدد کوچکتر رو بر تدد بزرگتر تقسیم کنیم چون کپتر از یک میشه توی cast صفر میشه
Omid.azadeh@live.com
خوب ایده خوبیه که باید دوتا مشکل اساسش رو حل کنید
اولی مساله باقی مانده بر صفر است که خطای تعریف نشده در برنامه ایجاد میکنه و باعث میشه برنامه از کار بیفته
دوم این که بعد از کست به متغیر 16 بیتی لذوما جواب صفر یا یک نیست که ملاک انتخاب قرار بگیره
و ببخشید یک نکته ی دیگه هم ماند که ذکر کنم
در اصل اسم این نوع توابع معمولا تک خطه در زبان سی function like macro
هستش
ابته کد قبل را اصلاح میکنم
اسم تابع را در دیفاین فراموش کرده بودم بنویسم
;int a , b
(;{ define sisoog (a,b) ({ a > b ? a : b#
()int main
}
;int out = 0
;(out = sisoog (10,100
{
یله الان درست شد – حتی نیازی به تعریف متغییر های a و b هم نبود
سلام پاسخ بنده به صورت زیر هست :
;int a , b
(;{ define (a,b) ({ a > b ? a : b#
()int main
}
;int out = 0
;(out = sisoog (10,100
{
همان طور که مشخصه توی کد بالا از یک تابع تک خطه با دستور دیفاین استفاده کردم چیزی شبیه دستور لامبدا در پایتونه
دستور تک خطه که دارای دو ورودی آ و ب هست انها را دریافت کرده و با هم مقایسه میکند و عدد بزگتر را در خروجی برمیگرداند
نحوی صدا زدن تابع تک خطه هم مشخه اسم تابع که سیسوگ هست رو مینوسیم و بعد به عنوان مثال دو ورودی بهش میدهیم 10 و 100
و نیجه ی مقایسه را در متغیر اوت ذخیره میکنه
سلام دوست عزیز – اون چیزی که شما نوشتید در واقع تابع نیست و ماکرو هست که با استفاده از دیفاین تعریف کردید ! ولی چرا شروط رو نادیده گرفتید و از مقایسه کوچکتری بزرگتری استفاده کردید ؟