مسابقه دوم : چالش برنامه نویسی C

۱۳۹۸-۱۲-۲۵

31 دقیقه

مسابقه اول سیسوگ (مسابقه اول: درک سخت افزار) انتقادهای زیادی رو در پی داشت تا جایی که حتی خودمم به نتیجه مسابقه شک کردم!!‌ یکی دو روز وقت گذاشتم و به بهینه‌ترین شکل ممکن برنامه را به زبان اسمبلی باز نویسی کردم و در کمال تعجب نه تنها نتیجه تغییر نکرد بلکه اختلاف حتی بیشتر هم شد اگر شما عملی تست کردید و نتیجه غیر از چیزی بود که ما اعلام کردیم خوشحال می‌شویم که نتیجه را با هم بررسی کنیم!!

بگذریم این بار قرار چالش ساده‌تر از قبل داشته باشم و فعلاً کاری به سخت افزار نداشته باشم و یکم مسابقه را نرم افزاری کنیم و باید زبان مورد استفاده زبان C است.

صورت مساله:

تابعی بنویسید که دو عدد (از نوع بدون علامت ۱۶ بیتی) را دریافت کند و بزرگ‌ترین عدد را برگرداند!

احتمالاً تا اینجا مقداری خنده دار به نظر می‌رسد چرا که به سادگی یک خط زیر می‌شود تابع را نوشت:

uint16_t Max(uint16_t A,uint16_t B)
{
	return (A>B) ? A:B;
}

uint16_t Max(uint16_t A,uint16_t B)

{

return (A>B) ? A:B;

}

البته قرار نیست مسابقه این چنین ساده باشد و لازم است که شرط‌های دیگری هم به آن اضافه کنیم

نباید از هیچ گونه ساختار شرطی استفاده شود (حتی شرط‌های درون بدنه حلقه)
از هیچ تابعی نباید استفاده شود مگر آن که بدنه آن با توجه شرط اول باز نویسی شود.

احتمالاً مقداری کار سخت‌تر شد! ولی همچنان راه حل‌های فراوانی می‌توانید در اینترنت برای این مسئله پیدا کنید که چند نمونه از آنها را در ادامه قرار می‌دهیم.

int max(int x, int y)  
{  
    return x - ((x - y) & ((x - y) >>  
            (sizeof(int) * 8 - 1)));  
}

int max(int x, int y)

{

return x - ((x - y) & ((x - y) >>

(sizeof(int) * 8 - 1)));

}

یا

// Function to find the largest number 
int largestNum(int a, int b) 
{ 
    return a * (bool)(a / b) + b * (bool)(b / a); 
}

// 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 برای مقایسه بین اعداد انجام میشه رو اینجا پیاده سازی کنیم. که در واقع این میشه راه مستقیم و یه راه غیر مستفیم هم وجود داره که میشه پیاده سازی توابع جمع و تفریق با کمک گیت های منطقی و استفاده از آنها مطابق معادلات ریاضی مربوطه.

همونطور که پیداست روش اول روش کوتاه تری است٬ و البته پیاده سازی آن هم ساده تر است پس ما هم به سراغ همین راه حل خواهیم رفت. مقایسه دو عدد با کمک گیت های منطقی واقعا ساده است٬ به جدول زیر دقت کنید

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 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 نیاز است. اما متغییر های ما یک بیتی نیستند بلکه ۱۶ بیتی هستند در ضمن مساله که باید به آن توجه داشت ارزش بیت ها است که اگر هر کدام از آنها بیت با ارزش بیشتر داشت قطعا آن عدد بزرگ تر است. پس لازم است که ورودی از مقایسه در مرحله قبل را نیز داشته باشیم. که به سادگی با عبارت زیر قابل تشخصی خواهد بود

( A & ~(B) ) ^ ( C & ~(A ^ B) )

1	( A & ~(B) ) ^ ( C & ~(A ^ B) )

بر اساس همین عبارت و گسترش آن برای ۱۶ بیت به سادگی میتوان این مساله را حل کرد. تنها نکته ای که میماند انتخاب عدد بزرگتر است٬ عبارت فوق خروجی صفر یا یک خواهد داشت چطور می توانیم صفر یا یک را عدد بزرگتر تبدیل کنیم ؟؟؟؟

جواب ساده است با استفاده از آرایه. ایندکس صفر آرایه را عدد b قرار میدهیم و ایندکس یک آن را عدد a. وقتی خروجی عبارت یک باشد یعنی a بزرگتر است و ماا لازم است ایندکس یک آرایه را برگردانیم و وقتی صفر باشد که یعنی b بزرگتر است ایندکس صفر آرایه برمیگردانیم. به همین سادگی کار تمام است. به کد زیر دقت کنید :

#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)];
}

#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)];

}

خب دوازده نفر تا الان پاسخ درست را ارائه کردند که روش و راه حل اونها را میتونید در زیر ببنید

نفر اول آقای محمود نقدی :

#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);
}

#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);

}

نفر دوم آقای محمدجواد واعظ :

#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;
}

#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;

}

نفر سوم آقای مهدی خلیلی فر :

#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);
}

#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);

return (a & aFlag) | (b & ~aFlag);

}

نفر چهارم آقای شهرام نوربخش راد:

#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

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

نفر پنجم آقای کامین جلیلی:

#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);

}

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);

}

نفر ششم آقای سعید گرجی:

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);
}

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);

}

نفر هفتم آقای رسول بیرانوند:

#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;
}

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;

}

نفر هشتم آقای مهدی راهی:

#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);
}

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);

}

نفر نهم آقای علی ترابی

#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&dd;
        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)
//{
//
//
//}

#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&dd;

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)

//{

//}

نفر دهم آقای پوریا

#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;
}

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;

}

نفر یادهم آقای محسنیان

#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;
}

#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;

}

نفر دوازدم آقای اصغر گرزین:

#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);
}

#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);

}

نفر سیزدهم آقای احمد:

#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;
}

#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;

}

نفر چهاردهم عنایت جوادی :

#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];
}

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 :

#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)) );
}

#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;

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)) );

}

نفر شانزدهم آقای معین :

#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)));
}

#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));

return ((Mm&flag) | (Nn&(~flag)));

}

نفر هفدهم آقای سوران:

#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;
}

#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 پیغام بدند تا جایزه خدمتشون ارائه بشه.

اطلاعات

222

لینک و اشتراک

مسابقه دوم : چالش برنامه نویسی C

صورت مساله:

پیش شرط ها

اما جایزه

ارسال جواب

شروع سال جدید و پایان چالش دوم سیسوگ

اعلام برنده های مسابقه:

شاید برای شما مفید باشد

آموزش میکروکنترلر STM32 قسمت هشتم:...

تایمر 4 در STM8 |...

سیاهچاله‌ای به نام پروژه

Zeus ‌

پالت | بازار خرید و فروش قطعات الکترونیک

آیسی | موتور جستجوی قطعات الکترونیک

فروشگاه سیسوگ

سیسوگ فروم | محلی برای پاسخ پرسش‌های شما

نویسنده شو !

نویسنده شو !

پالت | بازار خرید و فروش قطعات الکترونیک

آیسی | موتور جستجوی قطعات الکترونیک

فروشگاه سیسوگ

سیسوگ فروم | محلی برای پاسخ پرسش‌های شما

دیدگاه ها

مهدی گفت :

Sisoog Os گفت :

M4m گفت :

زئوس Zeus گفت :

m4m گفت :

زئوس Zeus گفت :

هیچکس گفت :

Sisoog Os گفت :

محم گفت :

Sisoog Os گفت :

مرتضی گفت :

زئوس Zeus گفت :

مرتضی گفت :

زئوس Zeus گفت :

علی ترابی گفت :

Sisoog Os گفت :

Sisoog Os گفت :

محمد امین باقری هامانه گفت :

زئوس Zeus گفت :

ali asghar gorzin گفت :

زئوس Zeus گفت :

ali asghar gorzin گفت :

زئوس Zeus گفت :

ehsan گفت :

زئوس Zeus گفت :

ehsan گفت :

زئوس Zeus گفت :

ali asghar gorzin گفت :

Sisoog Os گفت :

ali asghar gorzin گفت :

زئوس Zeus گفت :

ali asghar gorzin گفت :

ali asghar gorzin گفت :

زئوس Zeus گفت :

ali asghar gorzin گفت :

رهام گفت :

زئوس Zeus گفت :

رهام گفت :

رهام گفت :

زئوس Zeus گفت :

roham گفت :

ali asghar gorzin گفت :

زئوس Zeus گفت :

ali asghar gorzin گفت :

زئوس Zeus گفت :

جواد عالمی گفت :

زئوس Zeus گفت :

ali asghar gorzin گفت :

زئوس Zeus گفت :

aLimec گفت :

زئوس Zeus گفت :

سوران میرزاپور گفت :

زئوس Zeus گفت :

سوران گفت :

زئوس Zeus گفت :

سوران گفت :

زئوس Zeus گفت :