合計 昨日 今日

アバター
kerotan0820
 
記事: 91
登録日時: 2010年11月19日(金) 04:04
お住まい: 東京都
日記: 日記を見る (42)
日記
- 2月 2015
+ 1月 2014
+ 12月 2013
+ 8月 2012
+ 7月 2012
+ 3月 2012
+ 9月 2011
+ 8月 2011
+ 6月 2011
+ 5月 2011
+ 4月 2011
+ 2月 2011
+ 1月 2011
+ 12月 2010
+ 11月 2010
カテゴリー
カテゴリに指定された日記はありません
フィード
次へ

C言語をかじりPICをかじり…そろそろ落ち着きたい

パーマリンクby kerotan0820 on 2015年2月16日(月) 19:50

大変ご無沙汰しております。
このサイトを初めて利用させていただいてから早くも5年ほど経過しました。

飽きっぽく継続性のない私ですが工学の分野からは逸れないようにコツコツいろいろやってきました。

長い年月が掛かりましたが、やっと継続は力なりという言葉が身に染みてきたところであります。
最近、個人ではdsPICで音声信号を扱ってみることに試みていたり、大学の部活ではマルチコプター製作を始めます。
これらの製作物を操作するためにウィンドウズプログラミングでシリアル通信を行える簡易的なアプリを作ってみたいと思うようになり、一度逸れていたプログラミングの道から遠回りして帰ってきたところです。

数ヶ月から1年ぐらいのスパンで圧倒的な成長を見出せる方々を見てはすごいな~と思いますが、私も存在を忘れられない程度に成果を発表できるようがんばりたいと思います。

何が言いたかったのかというと、いろいろぶれてはいるけど今までやってきたことが所々でリンクしてきた!という喜びの報告でした。

興味本位のプログラミング(C) <--> PIC(C) <--> 電子工作(C) <--> 制御ソフト制作(winapi C)

これからもサイトがある限りお邪魔させていただきたいと思いますのでよろしくお願いいたします。

ps.
5年前の自分の日記を見ると非常に恥ずかしいですね!
最後に編集したユーザー kerotan0820 [ 2015年2月16日(月) 19:53 ], 累計 1 回

コメント数: 0 閲覧数: 15768

関数が使えないけど関数電卓を作ってみた

パーマリンクby kerotan0820 on 2014年1月10日(金) 16:58

四則計算の優先順位も考慮してないです。
関数もないです。
よくデータ消しちゃったりするのでメモ感覚で日記にあげました・・・。
コード[C++]: 全て選択
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
 
#include <stdio.h>
#include <stdlib.h>
#include "kota_string.h"
 
void divide_formula( char *formula, double *figure, char *symbol);
double calculate( double *figure, char *symbol);
void batsu();
 
int kou_num = 0;
 
int main( )
{
    setbuf(stdout,0);//msPEwb2Kの制限:main関数の最初の実行文の前に置く
 
    char formula[100] = {"\0"}, symbol[100] = {"\0"};
    double figure[100] = {0}, sum = 0;
 
    printf("式:");
    fgets( formula, sizeof(formula), stdin);
 
    if( strchr( formula, '\n') != NULL ) {
        // 改行文字を終端記号に置換
        formula[ kota_strlen(formula) - 1] = '\0';
    } else {
        // 入力ストリームをクリア
        while( getchar() != '\n' );
    }
 
    divide_formula( formula, figure, symbol );  //式を文字と記号に分ける
    sum = calculate( figure, symbol );  //計算する
 
    printf("Ans:%f\n", sum);
 
    batsu();
    return 0;
}
 
/********************* divide_formula( ) **********************/
//数字と記号を分ける
void divide_formula( char * formula, double *figure, char *symbol)
{
    char fig[20];
    int i=0, j=0,cnt = 0;
    for(kou_num = 0; *formula != '\0'; formula++){
        if( !(*formula >= '0' && *formula <= '9') && (*formula != '.') ) kou_num ++;
        cnt ++;
    }
    formula -= cnt;
 
    for(i = 0; i < kou_num; i++){
        while((*formula >= '0' && *formula <= '9') || (*formula == '.')){
            fig[j] = *formula;
            j ++;
            formula ++;
        }
        sscanf( fig, "%lf", figure);
        *symbol = *formula;
 
        memset(fig, 0x00, sizeof(fig));
        j = 0;
        formula ++;
        figure ++;
        symbol ++;
    }
        while(*formula >= '0' && *formula <= '9' || (*formula == '.') ){
            fig[j] = *formula;
            j ++;
            formula ++;
        }
        sscanf(fig, "%lf", figure);
        figure -= kou_num;
        symbol -= kou_num;
}
 
double calculate(double *figure, char *symbol)
{
    double sum = 0;
    int i;
    sum = *figure;
 
    for(i = 0; i < kou_num; i++){
        figure ++;
        switch( *symbol )
        {
            case '+':
                sum += (double)*figure;
                break;
            case '-':
                sum -= (double)*figure;
                break;
            case '*':
                sum *= (double)*figure;
                break;
            case '/':
                sum /= (double)*figure;
                break;
            default :
                puts("入力エラー");
                exit(1);
        }
        symbol ++;
    }
    return sum;
}
void batsu()
{
    int size = 0, i, j;
    printf("\n(おまけ)×の大きさ:"); scanf("%d",&size);
    for(i = 0; i < size; i++){
        for(j = 0; j < size; j ++)
            printf("%s", (i == j || (i + j) == (size - 1 ))?" ":"*");
        putchar('\n');
    }
}

コメント数: 2 閲覧数: 20445

CUIでテトリスを作ってみました。

パーマリンクby kerotan0820 on 2013年12月04日(水) 02:14

いくつか掲示板で力をお借りしましたが、なるべくウェブサイトなどは見ずに作ってみました。

http://u7.getuploader.com/kerotan/downl ... TRIS01.exe

構造体の使い方をまた忘れてしまったので本を読みながら無理やり使ってみました。
ブロックのデータなどはグローバル変数で宣言するのは好ましいのでしょうかね…。
かといってmain関数にブロックデータを全て書き込んだらきたないし…。
他の方のプログラムをいくつか見ていたら、tetris.h なんていうヘッダーを作っている方が何人かいた。

あと悩んでいるのが処理速度が不安定ということ。
キーボードの入力を受付けている間はタイマーがカウントされず、ブロックも落下しない…。
コレに関してはどうすればよいか想像もつきません。

高校生の時に先生に頂いた「ネコでも分かるゲームプログラミング」なんていう本が手元にあるので、WINAPIを勉強してみようかなと思っています。
やっと勉強してみようと思えるようになりました。

コード[C++]: 全て選択
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
/***** ヘッダー ****/
#include<stdio.h>
#include<stdlib.h>  //exit(),rand()
#include<time.h>    //time()
#include<conio.h>   //getch(),kbhit()
#include<windows.h> //Sleep()
 
/**** 定数 ****/
#define HIGHT 20
#define WIDTH 15
#define SUMBLOCKS 7
 
/**** プロトタイプ宣言 ****/
void Draw_map(void);                //ステージ(メイン)の出力
void Draw_block(int b);             //空白かブロックの出力
void Check_map();                   //ブロックの固定、新規ブロックの取得
int  Check_wall(int dir);                   //ブロック移動の制限
int  Check_roll(int dir);           //回転時の壁判定
void Check_line();                  //ラインが揃ってるか調べる
void Del_line(int line);            //ラインを一行削除
void Sort_block(int line);          //消されたラインを詰める
void Set_block(int mode);           //回転用ブロックのセット
void Move_block(int dir);           //ブロックの移動
void Turn_block(int dir);           //ブロックの回転
void Hold_block();                  //ブロックの固定
void Output_test(int type);
void Key_inp();
void Timer_funk();
void Title();                       //タイトルの表示
void Game_over();                   //ゲームオーバー画面
 
struct BLOCKS{              //ブロックデータ
    int block[4][4];        //最大4 * 4ドット
    int block_size;         //サイズ
};
struct BLOCKS block_data[SUMBLOCKS] =
{
    {//四角       //ブロック0
        {
            { 1, 1 },
            { 1, 1 }
        }, 2
    },
    {//とつ       //ブロック1
        {
            { 0, 1, 0 },
            { 1, 1, 1 },
            { 0, 0, 0 }
        }, 3
    },
    {//エル       //ブロック2
        {
            { 1, 0, 0 },
            { 1, 1, 1 },
            { 0, 0, 0 }
        }, 3
    },
        {//逆エル    //ブロック3
        {
            { 0, 0, 1 },
            { 1, 1, 1 },
            { 0, 0, 0 }
        }, 3
    },
        {//エヌ       //ブロック4
        {
            { 0, 1, 0 },
            { 1, 1, 0 },
            { 1, 0, 0 }
        }, 3
    },
        {//逆エヌ    //ブロック5
        {
            { 0, 1, 0 },
            { 0, 1, 1 },
            { 0, 0, 1 }
        }, 3
    },
        {//横棒       //ブロック6
        {
            { 0, 1, 0, 0 },
            { 0, 1, 0, 0 },
            { 0, 1, 0, 0 },
            { 0, 1, 0, 0 }
        }, 4
    },
};
struct BLOCKS block_data2[SUMBLOCKS];   //回転処理後のデータ
 
struct STAGE{
    int stage[20][15];  //ステージ全体 20*15
    int x;              //ブロックの現在位置 X
    int y;              //ブロックの現在位置 Y
    int direction;      //回転位置
    int ground;         //地面に付いているかいないか
    int b_type;         //落下中ブロックのタイプ
};
struct STAGE st =       //マップデータ
{
    {
        { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
        { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
        { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
        { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
        { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
        { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
        { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
        { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
        { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
        { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
        { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
        { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
        { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
        { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
        { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
        { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
        { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
        { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
        { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }
    }, 5, 0, 0, 0, 3
};
 
struct SCORE {
    int score;
    int delline;
    int turnnum;
};
 
struct SCORE score_data = {
    200,    //総合得点
    0,      //消したライン数
    0       //回転した回数
};
 
int GAMEOVER = 0;
 
/***********************************************************/
/************************* MAIN関数 ************************/
/***********************************************************/
 
int main(void)
{
    int c=0;
    Set_block(8);
    Title();    //タイトル
    printf("[S]Key:Start!\n");
    while (1){
        if (_kbhit() != 0){
            c = _getch();
            if (c == 115){              //S_key
                printf("Start!!!\n");
                break;
            }
        }
    }
    system("cls");
    Timer_funk();
    system("cls");
    Game_over();
    system("pause");
    return 0;
}
 
/**************** タイマー *******************/
void Timer_funk()
{
    int time=0;
    time = 0;
    while (GAMEOVER != 1){
        for (time = 0; time < 10; time++){
            Sleep(1);       //1[ms]のウェイト
            Key_inp();      //回転処理の常時受け付け
        }
        system("cls");
        Check_map();        //移動先のチェック
        Draw_map();
        st.y += 1;
    }
}
 
/**************** キー入力受付*****************●*/
void Key_inp()
{
    int key=0;
    if (_kbhit() != 0){
        key = _getch();
        if (key == 99){     //C_key(左回り)
            if(Check_roll(1)) Turn_block(1);
        }
        else if (key == 122){   //Z_key(右回り)
            if(Check_roll(0)) Turn_block(0);
        }
        else if (key == 75){        //←_key(左へ移動)
            if(Check_wall(-1)) st.x -= 1;   //現在地の左にブロックがなければ移動
        }
        else if (key == 77){        //→_key(右へ移動)
            if(Check_wall(1))  st.x += 1;   //現在地の右にブロックがなければ移動
        }
        system("cls");
        Draw_map();
    }
}
 
/**************** マップ描画 ******************●*/
void Draw_map()
{
    int i, j, size,sum=0;
    struct BLOCKS* bd = (st.direction % 2 == 0 ? block_data2 : block_data);
    size = block_data[st.b_type].block_size;
 
    for (i = 0; i < HIGHT; i++){            //マップ縦全体
        for (j = 0; j < WIDTH; j++){        //マップ横全体
            if( (i >= st.y && i <= st.y + size-1) && ( j >= st.x && j <= st.x + size-1) ){
                Draw_block(bd[st.b_type].block[i-st.y][j-st.x] + st.stage[i][j]);
            }else{
                Draw_block(st.stage[i][j]);
            }
            if(st.stage[i][j] == 1 ) sum += 1;  //ブロックが揃っているか調べる
            if(sum>=15 && i != 19) {
                Del_line(i);    //1行すべてが揃っていたら
                Sort_block(i);  //ブロックを詰める
                score_data.score += 100;    //スコアを+100
                score_data.delline += 1;    //消したライン数を+1
            }
        }
        printf("\n");
        sum = 0;
 
    }
//  printf("X=%02d Y=%02d\n", st.x, st.y);
    printf("DEL LINE: %d\n", score_data.delline);
    printf("TURN BLOCK: %d\n", score_data.turnnum);
    printf("TOTAL SCORE: %d", score_data.score);
}
 
/*************** 削除 *******************/
//呼び出し元:マップ描画
void Del_line(int line)
{
    int i;
    for(i = 1; i < WIDTH-1; i++){
        st.stage[line][i] = 0;
    }
}
 
/************** ブロックのソート **************/
//呼び出し元:マップ描画
void Sort_block(int line)
{
    int i,j;
    for(i = line; i > 0; i--){
        for( j = 1; j < WIDTH - 1; j++){
            st.stage[i][j] = st.stage[i-1][j];
        }
    }
}
 
/************* 空白orブロック描画 ************●*/
 
void Draw_block(int b)
{
    if(b >= 1) printf("■");
    else printf(" ");
}
 
/********** 回転用ブロックのセット ***********●*/
 
void Set_block(int mode)    //mode:8 全初期化 mode:0~6 指定初期化
{   //初期ブロックデータを回転用データにセット
    int i, j, k, size;
    if (mode == 8){ //全初期化
        for (i = 0; i < SUMBLOCKS; i++){
            size = block_data[i].block_size;
            for (j = 0; j < size; j++){
                for (k = 0; k < size; k++){
                    block_data2[i].block[j][k] = block_data[i].block[j][k];
                }
            }
        }
    }
    else if (mode >= 0 && mode <= 6){
    }
}
 
/*************** あたり判定 *******************●*/
void Check_map()
{
    int i, j, size;
    struct BLOCKS* bd = (st.direction % 2 == 0 ? block_data2 : block_data );
    size = block_data[st.b_type].block_size;
 
    for(i = st.y; i < st.y + size; i++){                    //現在のY座標から現在のY座標+ブロックのサイズ分
        for(j = st.x; j < st.x + size; j++){                //現在のX座標から現在のX座標+ブロックのサイズ分
            if( bd[st.b_type].block[i-st.y][j-st.x] * st.stage[i+1][j] == 1){
                Hold_block();                               //ブロック固定
                break;
            }else if(i == st.y + size && j == st.x + size){ //配列末までマップとの重複なし
                st.y += 1;                                  //y座標をひとつ下げる
            }
        }
    }
}
 
/*************** 壁のあたり判定 *******************●*/
int Check_wall(int dir)
{
    int i, j , size;
    struct BLOCKS* bd = (st.direction % 2 == 0 ? block_data2 : block_data );
    size = block_data[st.b_type].block_size;
   
    for(i = st.y; i <st.y + size; i++){
        for(j = st.x;j < st.x + size; j++){
            if( bd[st.b_type].block[i-st.y][j-st.x] * st.stage[i][j+dir] == 1){
                return 0;   //移動不可能
            }else if(i == st.y + size && j == st.x + size){//配列末までマップとの重複なし
                return 1;   //移動可能
            }
        }
    }
}
 
/*************** ブロック回転時のあたり判定 ******************/
int Check_roll(int dir)
{
    int i, j, size;
    struct BLOCKS* bd = (st.direction % 2 == 0 ? block_data2 : block_data);
    size = block_data[st.b_type].block_size;
 
    if(dir == 1){       //右回転のあたり判定
        for( i = 0; i < size; i++){
            for( j = 0; j < size; j++){
                //現在のブロックの回転先に障害物あり
                if(( bd[st.b_type].block[i][j] * st.stage[j + st.y][(size - i - 1) + st.x]) == 1){
 
            //      printf("現在のブロック [%d][%d]\n", st.y + i, st.x + j);
            //      printf("回転後ブロック [%d][%d]\n", j + st.y, size - i + st.x);
            //      system("pause");
 
                    return 0;
                }
                if( i == st.y + size && j == st.x + size) return 1;
            }
        }
    }else if(dir == 0){ //左回転のあたり判定
    }
}
 
/*************** ブロック固定 *******************/
void Hold_block()
{
    int i,j,size;
    size = block_data[st.b_type].block_size;
    for(i=st.y; i < st.y + size; i++){              //現在のY座標から現在のY座標+ブロックのサイズ分
        for(j=st.x; j < st.x + size; j++){          //現在のX座標から現在のX座標+ブロックのサイズ分
            if (st.direction % 2 == 0 && block_data2[st.b_type].block[i-st.y][j-st.x] != 0){//回転回数偶数でブロックデータがあれば
                st.stage[i][j] = 1; //ブロック情報をマップに書き込み
            }
            else if(st.direction % 2 != 0 && block_data[st.b_type].block[i-st.y][j-st.x] != 0){
                st.stage[i][j] = 1; //ブロック情報をマップに書き込み
            }
        }
    }
 
    for(i = 1; i < WIDTH-1; i++){
            if(st.stage[0][i] == 1){
                GAMEOVER = 1;
                return;
            }
    }
 
    st.y = 0;                       //ブロックの開始位置を初期化
    st.x = 5;
    srand((unsigned) time(NULL));   //新規ブロックの取得
    st.b_type = rand() % SUMBLOCKS;
    Sleep(10);  //ブロック出現まで少し待機
}
 
/*************** ブロック回転 *****************/
 
void Turn_block(int dir)    //回転方向
{
    int i, j;
    int size = block_data[st.b_type].block_size;                //ブロックのサイズ
 
    for (i = 0; i < size; i++){
        for (j = 0; j < size; j++){
            if (dir == 1){                      //右回なら
                if (st.direction % 2 == 0){             //回転位置(偶数):b←a
                    block_data[st.b_type].block[j][size - 1 - i] = block_data2[st.b_type].block[i][j];
                }
                else{                                   //回転位置(奇数):a←b
                    block_data2[st.b_type].block[j][size - 1 - i] = bloc...


[ 続き ]
最後に編集したユーザー kerotan0820 [ 2013年12月04日(水) 02:17 ], 累計 2 回

コメント数: 3 閲覧数: 2120

入力した10進数を2進数で表示するプログラム

パーマリンクby kerotan0820 on 2012年8月21日(火) 21:32

出来ましたよ、出来ました!

コード[C++]: 全て選択
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include<stdio.h>
 
int waru_cnt( unsigned );
 
int main(void)
{
    unsigned int in=0;
    int cnt=0,i;
 
    printf("符号なし10進数:");  scanf("%d",&in);                               
 
    cnt = waru_cnt(in);
 
    printf("2進数:");
    for(i=cnt; i>=0; i--) printf("%d",(in>>i)&1);
    puts("");
}
 
int waru_cnt ( unsigned in)
{
    int cnt=0;
    do{
        if(in != 0 && in != 1) cnt++;
        in /= 2;
    }while(in !=0 && in != 1);
 
    return cnt;
}


これで、出来るはずです…!
改善したほうが良い点等、ありましたらご指摘頂けると幸いです。

とりあえず動いて嬉しいです。

コメント数: 8 閲覧数: 23970

10進数を2進数に変換するプログラムを組もうとしてるけど…

パーマリンクby kerotan0820 on 2012年8月20日(月) 12:32

題名の通りのプログラムを組んで関数化したら、課題研究で組んでるプログラムのデバッグがしやすいな~と思い組んでたけど、プログラムが荒れに荒れています。

コード[C++]: 全て選択
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
/*
---------------------------------
割   2   割     あ
る   で   っ     ま
数   割   た     り
        数
a               b           c
7 ÷ 2 = 3 あまり 1
3 ÷ 2 = 1 あまり 1
----------------------------------
*/
#include<stdio.h>
 
int main(void)
{
    char buff[17]={' '};
    int a=0,i=0,wa=0;
 
    printf("10進(65535以下):");   scanf("%d",&a);
    while(1)
    {
        wa = a;             //入力した値を2で割った余りを計算するためコピーをとる
        a = a / 2;          //入力した値を2で割って代入(1かその他)
        wa = wa % 2;            //入力した値の2で割った余り(0か1)
 
        if(a==0)
        {
            buff[i] = '0';
            break;
        }
 
        if(wa==0)   buff[i] = '0';
        else        buff[i] = '1';
       
        if(a==1)                //割った値が1ならば1を最上位ビットに。
        {
            if(buff[0]!=(0||1)) i+=1;
 
            buff[i] = '1';  //1を最上位ビットに代入
            break;          //割った値が1→もう2で割れないから終了
        }
 
        i+=1;               //iに1を加算
    }
    printf("%016s\n",buff);
 
    return 0;
}


うぇうぇ…(´;ω;`)
単純に2でわってその余りの数を記録して2進数に変換しようと思ったのですが、実際組んでみると、最初に1や0が入力されたらどう処理すれば良いのかといった処理に頭がこんがらがる…。

2進数で出力する関数が標準関数として無いだけで、処理自体はビット演算を用いることが出来るのだから、シフトして、0000 とかを&すれば、各ビットの値は取り出せるんじゃないのとか今更ながら思い始めた(マスキングというのでしたっけ...)

バイトから帰宅したらやってみようと思う!

また、皆様の意見などが聞けたら幸いに思います。
では、働いてきます。


追記:
このプログラムは、もし 3 が入力されたら、というのを仮定して組んでいました。
3の場合問題なく出力されますがそれ以外は正しく動作しません。
最後に編集したユーザー kerotan0820 [ 2012年8月20日(月) 12:33 ], 累計 1 回

コメント数: 5 閲覧数: 22885

オンラインデータ

登録ユーザー: みけCAT