int Remain(int numer, int denom);

int Remain(int numer, int denom) {	 // numer >= 0 && denom > 0 でないとハマる
	while (numer > denom) {
		numer -= denom;
	}
	return numer;
}

解禁日になったので投稿。(2 パターン)

int Remain(int number, int denom){

    int quot;
    
    if(denom == 0){
        printf("denom must not be zero\n");
        exit(0);
    }
    
    quot = number / denom;
    
    return number - quot * denom;
}

int Remain(int number, int denom){

    int sign = 1;
    
    if(denom == 0){
        printf("denom must not be zero\n");
        exit(0);
    }
    
    if(denom < 0) denom *= -1;
    
    if(number < 0){
        sign = -1;
        number *= sign;
    }
    
    while(number > denom){
        number -= denom;
    }
    
    return number * sign;
}

//
//  %(剰余演算子)の実装
//

//
#include <stdio.h>

//
#define remain( a, b )  (a - a / b * b)

//
int Remain( int numer, int denom );

//
//
int main( void )
{
    int a, b;
    
    //
    scanf( "%d%d", &a, &b );
    
    //
    printf( "%d %% %d = %d\n", a, b, a % b );
    
    printf( "Remain( %d, %d ) = %d\n", a, b, Remain( a, b ) );
    
    printf( "remain( %d, %d ) = %d\n", a, b, remain( a, b ) );
    
    return 0;
}

//
int Remain( int numer, int denom )
{
    return numer - numer / denom * denom;
}

正数だけを考えるなら…
// (1)
int Remain(int numer, int denom) {
    return numer - numer / denom * denom;
}

0除算による未定義動作を防ぐなら…
// (2)
int Remain(int numer, int denom) {
    if (!demon) exit(1);
    return numer - numer / denom * denom;
}

# 入門者・初心者は (1), (2) と同等の答えを出すことができれば合格


さらに負数について考えるなら…

-5 / 3 は -1 余り -2 と -2 余り  1 の二通りの答えがある。

問題の指示より，分母と分子の片方が負数の時の商は
切り上げであることが分かる。
ex. -5 / 3 ≒ -1.6666 ≒ -1
# つまり，商は常に 0 方向へ切り捨てられる

処理系が，C99 準拠であるか，または C99 準拠ではないが
/ (除算演算子)が商を 0 方向へ切り捨てる実装を
選択しているならば (2) で十分である。
  
そうではない場合，除算演算子を自分で実装して
// (3)
int Divide(int numer, int denom) {
    // 実装
}

int Remain(int numer, int denom) {
    return numer - Divide(numer, denom) * denom;
}

と除算演算子を置き換えるか，

// (4)
int Remain(int numer, int denom) {
    // 全く別のアプローチで実装
}

とする必要がある。
初心者も (3), (4) に挑戦するがよろし。

> # すでに回答が出ていますが，用意していた解説などを貼り付け

割り切れるときに余りが 0 にならない解答もあるようですが。


> // (4)
> int Remain(int numer, int denom) {
>     // 全く別のアプローチで実装
> }

コンピュータの基本を理解するためなら、

#include <limits.h>

int Remain_u(unsigned int x, unsigned int y)
{
    int i = sizeof(int) * CHAR_BIT;
    while (i--)
       if (x >> i >= y) x -= y << i;
    return x;
}

int Remain(int numer, int denom)
{
    /* if (denom == 0) exit(1); */
    if (denom < 0) denom = -denom;
    return (numer < 0) ? -Remain_u(-numer, denom) : Remain_u(numer, denom);
}

携帯や PDA などによく使われている ARMプロセッサには除算命令がないから、
シフトと減算で似たようなことをやっているはずです。

#include <stdio.h>

void divide(int numer, int denom, int *quot, int *rem)
{
    unsigned int x = (numer < 0) ? -numer : numer;
    unsigned int y = (denom < 0) ? -denom : denom;
    unsigned int z = 0;
    unsigned int i = !(x >>  8) ?  8 :
                     !(x >> 16) ? 16 :
                     !(x >> 24) ? 24 : 32;
    do {
        if (x >> --i >= y) {
            x -= y << i;
            z += 1 << i;
        }
    } while (i);
    if (rem) *rem = (numer < 0) ? -x : x;
    if (quot) *quot = (numer ^ denom) < 0 ? -z : z;
}

int main(void)
{
    int a, b, q, r;

    while (scanf("%d%d", &a, &b) == 2) {
        divide(a, b, &q, &r);
        printf("%d / %d = %d, %d %% %d = %d\n", a, b, q, a, b, r);
    }
    return 0;
}

    while (numer > denom) {

    while (numer >= denom) {

#include <stdio.h>

#define remain( a, b )  (a - a / b * b)

int main(void) {
    int remainder = remain(1-1 /* 0? */, 1);
    printf("0 %% 1 = %d?\n", remainder);
    return 0;
}

    if (!demon) exit(1);

    if (!denom) exit(1);

毎回有用なコードを挙げてくださり感謝します。
感想中心ですが，疑問もあるので教えてください。

>ということで、シフトと減算と加算で、余りと商を求めるプログラムを示します。

ふむふむ。十進数の割り算の筆算と同じ考え方なわけですね。


>ループを常に 32回まわるのは無駄なので、その回数をちょっと減らす工夫を
>してみました。
>    unsigned int i = !(x >>  8) ?  8 :
>                     !(x >> 16) ? 16 :
>                     !(x >> 24) ? 24 : 32;

4bit単位あるいは16bit単位でないのはなぜですか?
分けるbitを細かくすれば，元のループと変わらなくなるのは
分かりますが，どのように最適化するのでしょうか?
考え方を教えてください。(単純な気もするが…)


>    if (quot) *quot = (numer ^ denom) < 0 ? -z : z;

分かったときには目から鱗でした。符号で使われる最上位ビットだけに
注目すればよいわけですね。

>>ループを常に 32回まわるのは無駄なので、その回数をちょっと減らす工夫を
>>してみました。
>>    unsigned int i = !(x >>  8) ?  8 :
>>                     !(x >> 16) ? 16 :
>>                     !(x >> 24) ? 24 : 32;
>
> 4bit単位あるいは16bit単位でないのはなぜですか?
> 分けるbitを細かくすれば，元のループと変わらなくなるのは
> 分かりますが，どのように最適化するのでしょうか?
> 考え方を教えてください。(単純な気もするが…)

単純ですよ。常に 32回まわるのが無駄ということから、
unsigned int i = !(x >> 16) ? 16 : 32; でもよいし、
unsigned int i = !(x >> 12) ? 12 : !(x >> 24) ? 24 : 32; でもよいで
しょう。あまり細かくすると余計に時間がかかって意味がなくなるという
ことで、適当です。

本当は、unsingned int i = LeftMostOne(x) - LeftMostOne(y) + 1;
としたいところです。ここで、LeftMostOne(x) は
x の最上位の 1 のビット位置を求めるものとします。

#define LeftMostOne(x) ((int)(log(x) / log(2))

と定義しても、誤差のため、正しい値にならないこともありますし、
log を使って速くなるわけがありませんから、本末転倒です。
ハードウェアにそういう命令があればよいのですが、そうなるとアセンブラで
書くしかなくなるでしょう。DEC の VAX や Motorolla の MC68020 にはそんな
命令があったような気がするんですが、Intel の Pentium はどうなんでしょう。

> あまり細かくすると余計に時間がかかって意味がなくなるという
ことで、適当です。

分かりました。ありがとうございます。


# 以下，処理系依存&脱線気味です。

>ここで、LeftMostOne(x) は
>x の最上位の 1 のビット位置を求めるものとします。
>(snip)
>Intel の Pentium はどうなんでしょう。

IA-32 インテル - アーキテクチャソフトウェア・デベロッパーズ・マニュアル
中巻A：命令セット・リファレンスA-M P95より

BSR - Bit Scan Reverse
説明
ソース・オペランド（第2 オペランド）を検索して、
最上位のセットビット（値1 のビット）を探す。
最上位のセットビットが見つかると、そのビット・インデックスが
デスティネーション・オペランド（第1 オペランド）にストアされる。
 
Windows XP Pro/VC6 with インラインアセンブラ/AMD Duron (Applebred) 1600.00 MHz:
void divide(int numer, int denom, int *quot, int *rem)
{
    unsigned int x = (numer < 0) ? -numer : numer;
    unsigned int y = (denom < 0) ? -denom : denom;
    unsigned int z = 0;
    int i;
    __asm {
        push eax    ; eax 保存
        push ebx    ; ebx 保存
        bsr eax, x  ; eax は x の最上位ビットのインデックス
        jnz X_END   ; ただし ZF がセットされたときは
        xor eax,eax ; eax が未定義なので 0 を代入
X_END:
        bsr ebx, y  ; ebx は y の最上位ビットのインデックス
        jnz Y_END   ; ただし ZF がセットされたときは
        xor ebx, ebx; ebx が未定義なので 0 を代入
Y_END:
        sub eax, ebx; eax -= ebx;
        inc eax     ; ++eax;
        mov i, eax  ; i = eax;
        pop ebx     ; ebx 戻す
        pop eax     ; eax 戻す
    }
    while (i-- > 0) {
        if (x >> i >= y) {
            x -= y << i;
            z += 1 << i;
        }
    }
    if (rem) *rem = (numer < 0) ? -x : x;
    if (quot) *quot = (numer ^ denom) < 0 ? -z : z;
}
ASM書くのは初めてだったり。
読む事はあるのだけどね。

# コードが間違ってたので修正版UP
# i が unsigned だったのではまりました…。

#include <stdio.h>

__inline int bsr(unsigned int x) { __asm bsr eax, x }

void divide(int numer, int denom, int *quot, int *rem)
{
    unsigned int x = (numer < 0) ? -numer : numer;
    unsigned int y = (denom < 0) ? -denom : denom;
    unsigned int z = 0;
    if (x && y) { 
        int i;
        for (i = bsr(x) - bsr(y); i >= 0; i--)
            if (x >> i >= y) {
                x -= y << i;
                z += 1 << i;
            }
    }
    if (rem) *rem = (numer < 0) ? -x : x;
    if (quot) *quot = (numer ^ denom) < 0 ? -z : z;
}

int main(void)
{
    int a, b, q, r;

    while (scanf("%d%d", &a, &b) == 2) {
        divide(a, b, &q, &r);
        printf(" %d / %d = %d, %d %% %d = %d\n", a, b, q, a, b, r);
    }
    return 0;
}

「絶対値で計算してから、どちらかのオペランドがマイナスならマイナスを付加する。」
と考えた。除算演算子使ったら駄目なのかな・・

int Divide(int numer, int denom){

    int sign = 1;
    
    if(numer < 0){ sign = -1; numer *= -1; }
    if(denom < 0){ sign *= sign; denom *= -1; }
    
    return numer / denom * sign;

}