いいアルゴリズムっていうか小技を教えて

たとえばaとbを入れ替えるとき、
普通は
　tmp = a;
　a = b;
　b = tmp;
みたいにやるところを、
　a = a + b;
　b = a - b;
　a = a - b;
ってやれば余計な変数を使わずに実現する！
みたいなちょっとした小技を教えてください。

見た人が「なるほど」って感動するようなやつを。

発作的に2ゲットずざー

>>1はトリップまで用意してスレを…
ウッウッ

N88BASICでは、コメントを付けないほうが速くなる。

>>3
そのわりに名前は1か

>>4
コンパイルしないスクリプト言語はぜんぶ
そうなんですかね？

かわいそうな>>１に乾杯

つか、

トリッキーなコード
http://pc.2ch.net/test/read.cgi/tech/983191866/

じゃだめなの？

a ^= b ^= a ^= b;
とかあるよ。

>>6
最近のやつは内部で中間コードに落としたりしてるから、
関係ないんじゃねーの?

>>9
じゃ中間コードに落とす時点での
速度差があるってことですかね？

ソースに ギガバイト単位の のコメントとか入れてるなら
遅くなるだろーけど、普通のソースだったら殆ど差なんか出ないだろ。

N88BASICは最近の言語じゃないし。

>>1のは実用的じゃない。

>>13　確かに。でもちょっと感動した。
a b cの中身を指定した順番に簡単に入れ替えれるやつないかな
漏れも今から考えてみるけど。

a = ( a - ( b = ( a = a + b ) - b ) );

>>15
>>1を横にしただけだけだけど面白いと思う

>>16
だけが１個多いだけだけだけど面白いと思う

【俺】　俺語でプログラミング　【語】
http://pc.2ch.net/test/read.cgi/tech/1016815283/6-9

のソースが意味不明なんだけど....
動かなかったし

まず眼科へ >>18
http://pc.2ch.net/test/read.cgi/tech/1016815283/10

>>19
すいません。見てなかった。
つか、Cのソースだったのか....

ﾊｧ...耳(外耳炎)の次は目か...

>>1
それは面白いが、良いアルゴリズムではないよ。

>>13>>21やっぱtmp使ったほうがいいですかね？

そこまで小技は知らんが「珠玉のプログラミング」はまともにおもろいよ。

>>22　そっちがいいとは限らないけど　
　多くの CPU は b=a-bは１命令に落ちないから　XOR の方がいいんだよ

じゃあ　除算命令が無いとして7で割った余りを求めるコード　は知ってる？

a = ???;
b = 7;
while(a > b){a=a-b;}

aに最初の数を入れれば、
最後にはaに余りが入るんじゃないかな。

bは7以外でも可かな？試してないから自信ないけど。

>>26　それはけど 実行時間が a に比例してしまうよ LOG(a)程度で済む方法を考えて

ヒント a mod 8 なら a and -8 で代用出来る。
　　　 -8 は ２の補数表現として 8bitなら 11111000　ね

そんなに難しいこと考えてよかったんだ。
可能な限り誰でもわかるようにわざわざ書いたのに。

待ってて書き直す。

あ　やっちゃった ミス

ヒント a mod 8 なら a and 8-1 で代用出来る。
　　　 8-1 は ２の補数表現として0000 0111　ね

b = 7 << 28; //28は適当
while( a != 0){
　if( a >= b ) a-=b;
　b = b >>1;
}

>>1
自ら宣言する余計な変数は減るかもしれないけど
明らかに遅くなるよ。a = a+bの時点で　
a+bを格納するための変数のコンストラクタが呼ばれているから。
わざわざ加算・減算のための関数をよんでるからオーバーヘッド
が発生する。
たとえaもbもただの32bit int 型だったとしてもオーバーフローする
可能性があるしバグ探しで見つかりにくい。
条件式なんかつけたらそれこそ投機実行で死んでくれるからね。
それよりも、値が早く、でるような、よい関数を、考えましょう。
テイラー展開。

>>30
　その方が汎用的だね　用意していた答えは

while( a>7 ) a=(a>>3)+(a&7) ; if( a>=7 )a-=7;

このwhile をバイナリ展開すれば　もっと早くなるけど

>>30
とまってないよ…
それってどんな値でも 0にならないか？

http://www.dd.iij4u.or.jp/~okuyamak/Information/xor_fixed_swapping.html

b = 7 << 28; //28は適当
while( a < 7){
　if( a >= b ) a-=b;
　b = b >>1;
}

a>7ね

>>31
整数演算ならマトモなコンパイラは関数呼び出しなんてやりません

そして整数演算ならオーバーフローしてもこの演算は必ず復帰しますよ

ってもしかして縦読み？

>>37
復帰するんだ。考えんかった。

>>38 ２次フィルターなんか (1-2Z+Z^2)/(略)、みたいな
感じだから途中オーバフローする訳だけど、結果さえ収まっていれば正しく計算出来るよ

>>34
単独なら意味ないかもしれないけど

ttp://www.infoeddy.ne.jp/~tensyo/prog/linealgo.htm

小さい方の絶対値を 1/2にして大きい方に足して返すらしい

ihypot(int a,int b)
{
a=abs(a);
b=abs(b);
{ register w=( ( a-b ) >> 31 ) & ( a^b ); /* a>bなら w=0 */
return ( a^w )+( b^w )/2;
}
}

なるべく短い行数でソートプログラム書いて
実行速度よりも行数優先で。

５個の変数（配列でも可）を昇順で。

どの言語でも簡単に応用できる程度にね。

>>41がエラそうだけどやってみよっと

>>41　動かんかな？
void SortIntArray(int n, int dt[])
{int i,j:
　for(j=0;j<n;j++)
　for(i=1;i<n;i++)
　{ int w=(dt[i] ^ int[i-1]) & ((dt[i]>int[i-1])*-1) ; //確か 条件式の結果は１か0だったよね？
　dt[i]^=w;
　dt[i-1]^=w;
　}
}

>>41
まっ課題としては面白いんだけど、実用的じゃないんだよな。

手元にあった Delphi6パーソナルで検証したコード

procedure SortIntArray(var dt:array of Integer);
var i,j,w:Integer;
begin
for j:=0 to High(dt)-1 do
for i:=j+1 to High(dt) do begin
　 w:=(dt[i] xor dt[j]) and ( ord(dt[i]>dt[j])*-1 );
　 dt[i]:=dt[i] xor w;
　 dt[j]:=dt[j] xor w;
end;
end;

ord(dt[i]>dt[j])*-1 を　減算してボローを見るアセンブラコードにすれば分岐無しソートになるぞ

やっぱ行数優先だったらバブルソートとXORの値交換だよな
その他のアイディアは無しか。
一応私も
#include <stdio.h>
#define sw(a,b) (a^=b,b^=a,a^=b)
int d[5]={42,11,56,34,22};
int main(){
int i,j;
for(i=4;i>0;i--)for(j=0;j<i;j++)if(d[j]>d[j+1])sw(d[j],d[j+1]);
for (i=0;i<5;i++)printf("%d\n",d[i]);
}
gccで検証

じゃ　速度優先だと？

void SortIntArray5(iint dt[5])

配列サイズは固定で

>>47　環境によって違うからねえ
　メモリアクセスコストが大きいなら比較して 5!=120通りに分岐するのが最速だし
　そんなコード見たい？

key = dt[0]&0xffff +
( (dt[1]<<16)&0xffff0000 )+
( (dt[2]<<16)&0xffff00000000 )+
( (dt[3]<<16)&0xffff000000000000 )+
( (dt[4]<<16)&0xffff0000000000000000 );

dt[0]=kotae[key][0];
dt[1]=kotae[key][1];
dt[2]=kotae[key][2];
dt[3]=kotae[key][3];
dt[4]=kotae[key][4];

kotae_table[100000000000000000000][5]={
.....
};

( (dt[1]<<16)&0xffff0000 )+
( (dt[2]<<32)&0xffff00000000 )+
( (dt[3]<<48)&0xffff000000000000 )+
( (dt[4]<<64)&0xffff0000000000000000 );
に訂正

(´Д`)・・・

うまい棒１０本買うときに、
レジ１０回通れば消費税がかからないよ。

>>52
示唆に富んでるなぁ…

葉書10枚を送れば500円かかるけど、
その葉書10枚を封筒に詰めて送れば500円はかからないよ。

>>53
某クロスワードの雑誌にはその方法を使うとよいと書かれているね。

普通はがき10枚はそれぞれ別の宛先に送るんじゃ…

>>55
懸賞とか。

じゃ>>29 のように a % n を a and(n-1) で代用出来るかどうか　
　つまり n が２のベキかどうかを高速に判定する方法

・・・これはスレも立ったことある問題だから知ってる人は多いかな？

官製はがき１０枚を封筒に入れて送ると５００円以上かかるという罠

BOOL IsBeki( int a ){
　int b=0;
　while( a!=0 ){
　　if( a&1 ) b+=1;
　　a = a >>1;
　}
return( b==1 ); //BOOLで返すの作ったこと無いので間違ってるかも
}

ああ、もっと速いアルゴリズムあるね。

送り主のところに宛先を書き、切手を貼らずにポストに投函するとどうなりますか?

サンタクロースに届けられます

良すれあげ。

BOOL IsBeki( int a ){
　int b=a;
　a |= (a>>16);b += (b>>16);
　a |= (a>>8);b += (b>>8);
　a |= (a>>4);b += (b>>4);
　a |= (a>>2);b += (b>>2);
　a |= (a>>1);b += (b>>1);
　return( (a==b) || (a==0) );
}

　return( (a==b) || (a!=0) );

return( (a==b) && (a!=0) );

>>64 苦労してるね　答えは　たった1行で判定出来る

じつは >>57 そのものがヒントになってるよ

もっとヒント出すと　逆に a% n == a &(n-1) になる nが必ず２のベキであるaの値は？

このスレずっとみてたけどぜんぜんわからん。
>>1のですら実験してみるまでわけわかんなかった。

a^=b^=a^=bもやっと意味わかった程度。

ビット演算なんかぜんぜんわからん。

みんなどーやって考えてるの。
よいページあったら教えてー。

そんなサイトあったらこんんあスレ立たないよ
つーか分からないんだったら素直に普通のコーディングしてれ。

さらにヒント a% n == a &(n-1) で a=n　と代入してみよう

なんか素直にやったら一行になった。

return (a > 0 && (a | (a - 1)) == (a + (a - 1))) ? 1 : 0 ;

答えはもっと簡単？

>>71
　違う答え用意してたけど　それでいいよ

用意してたのは
＝＞ (a>0) && ( 0 == (a&(a - 1) )

そっちの方が簡単だねえ。
a & (a - 1)は、他にも0になる値がありそうな気がして、
何となく避けてしもた。んなこたない

このネタスレみておもいついたんですけど、
多倍長計算のクラスをC++で組むときには
void Change(HOGE hoge1,HOGE hoge2);
みたいのを作っとくと後々便利ですかね？
hoge1 = temp;hoge1 = hoge2;hoge2 = temp;とかやると
メモリ確保とメモリコピーに無駄に時間がかかりそうなので。

std::swap を使って書いておいて、必要なら多倍長数クラス用に特殊化すれば良いのでは。
スレの趣旨とは違うｶﾞﾅｰ

sqrt() を使わずに hypot() を実装する方法 :
ttp://research.microsoft.com/~hollasch/cgindex/math/pythag-root.txt

>>74
多倍長というかある程度のサイズのオブジェクトはポインタで管理し、インスタンスは動かさないのが基本

しかし交換のつもりでchangeなんて命名するか…

ボクドキュソなんで英語わかんないんです。
Commutation(HOGE hoge1,HOGE hoge2);
でかまいませんか？

しかし交換のつもりでCommutationなんて命名するか…

交換は swap か exchange が普通。
commutation にも確かに交換という意味はあるけど、
プログラムで使ってるの見たことない。

>>74
自力でそういうことを考えたのは偉いと思う。
だけど、C++の良書にはそういうテクニックは普通に
載ってる。買って読もうな（推薦図書スレに行くべし）。

ちなみに、ホントに交換したいなら、

void Hoge::swap(const HOGE& hoge);

というメンバ関数にするのが一般的。

>>82
const相手のswapできるのかと

>>83
マジボケだ。すまん。

RGB565 形式の　アルファブレンドってのは　ありきたりすぎ？

MSB　　　LSB
　R:5 G:6: B:5

でR,G,Bのそれぞれ平均を求める計算

つか、今時のカードって殆ど555でないの？

>>86　そうなの？
ttp://www.geocities.co.jp/SiliconValley-PaloAlto/5989/trans01.html

とかで565でやってたから 565が多いのかと思った

じゃ 555で

>>1へ
a=a xor b
b=a xor b
a=a xor b
オーバーフローしない処理

DirectX8が動くのなら555がないのはあっても565がないものはない

>>85
それってアルファブレンドじゃなくて単なる半透明

じゃあ 565 で　アルファブレンドと　半透明の両方を

あのさ、 565とか555とか関係なんだよ

R,G,Bを その2^ビット位置として

　r1*R+g1*G+b1*B　が１ワードだとすると0<=α<=1の範囲なら

(r1*R+g1*G+b1*B)*α+(r2*R+g2*G+b2*B)*(1-α)

つまり、ビット位置に関係なく一つのワードとして処理すればいいんだよ

なんか判り難いな

つまり
int HarfBlend(int a, int b){ return ((long)a+(long)b)/(long)2;}

と書いておけば 565でも555でも888でも正しく動くという事

>>92
桁上がりが起きたら破綻するから駄目

桁上がりじゃなくて 　余りが下位に入ってしまうからダメ

余りの問題を解決する為に LSBが片方だけ1の時だけ事前に各LSBゼロにしておくというのがセオリー

論理演算でやるなら
888なら mask=(not ((a xor b) and $010101)) とマスクビットを用意して

return ( (mask and a)+(mask and b) )>>1;

ｵｵｳ　ﾌｧﾝﾀｽﾃｨｸ!

この人が　そういう手法の元祖だと主張しております

ttp://www.emit.jp/prog/prog_b.html

>>98
＞v2 = (v0 & v1) + (((v0 ^ v1) & 0xfefefefe) >> 1);

すごいね５演算か 　>>96のは7演算・・・完全に負けた

>>92の頭のほうがﾌｧﾝﾀｽﾃｨｯｸだ。

まさか特許とか取られてないよな。

未だに非MMXのアルファとかは大抵テーブルで実装してるんですが、
今時のCPUの場合、非MMXでもテーブル使うよりその場で
計算した方が速いんでしょか。

>>102　テーブルで実装という事は 8bit？

えと。。256色と言う意味で8bitならフルカラー・ハイカラーです。。。

コードは今忘れたけど、

386の頃に　αブレンド　１ピクセル毎の処理で
掛算１回ってのを作った事はあった。
８段階か１６段階だったかだけど

たぶん、　重みMから　 Y + ((X-Y)*M/16)

RRRRR GGGGGG BBBBB を _____ GGGGGG _____ RRRRR ______ BBBBB として

X-Y = X + (NOT X) +1 みたいにしてゴチャゴチャやったように思う

あ、X-Y = X + (NOT Y) +1　の間違いね

>>104　フルカラーでどうやってテーブルで実装するの？　逆に興味あるけど

フルカラーの場合はRGB別に[f][a]＋[255-f][b]。。。
て何か思いっきり阿呆な事してるんだろうか(;´Д｀)

>>105
こっちは掛算2回だけど、今なら掛算も１サイクルだからこっちがオトクかも
ttp://hp.vector.co.jp/authors/VA016117/assem/alpha2.html

ただ、16bit->32bitの展開でわざわざテーブルを使ってるみたい

>フルカラーでどうやってテーブルで実装するの？
104さんじゃないけど

for i:=0 to 510 do begin
for j:=0 to 255 do begin
AlphaTable[j,i]:=((j*(i-255)) div 255) and $ff;
end;
end;
で先にテーブルつくっておいて
dstR:=AlphaTable[alphaR,srcR-dstR+255]+dstR;
とかRGBにそれぞれやってたりします。>漏れ
遅いだろうしエレファントだし、ちょち不満だども
ゲーム用じゃないし、ちゃんと動いていればいいかなみたいな。

うちはもう素直に
b:=256-a;
c.r:=(p1^[x].r*a + p2^[x].r*b) div 256;
c.g:=(p1^[x].g*a + p2^[x].g*b) div 256;
c.b:=(p1^[x].b*a + p2^[x].b*b) div 256;
こうかな
div 256はシフトに変換されるし

自分ももう一回
BYTE TAlpha[256][256];
a=α; b=255-α;
DstR=TAlpha[a][SrcR]+TAlpha[b][DstR];
5年前に書いたDIB用ライブラリの、今でもそのまま(;´Д｀)

>>111 それはたぶん今なら
a=α; a+= (a>>7);
b=256-a;

DstR=(a*SrcR+b*DstR)>>8;

が速くなる

いや、a,bが固定なら　キャッシュヒットするから必ずしも遅い訳じゃないか　ゴメン

じゃこれならどうだろ？
DstR += b*(Src-DstR)>>8;

何となく >>111 を使ってるプログラム弄って負荷計ってみたり。
αレイヤ無し 37%
MMX 56%　　>>111＆112 77% 前後
>>114 はよく分かりませんでした；

何も考えずに そのまま書いて実行してみた所、
>>112そのままだと少し暗くなってしまいまいました。。

あ　あと >>111 はソース確認したら最初に a b じゃなく
LPBYTE lpTAd=TAlpha[a] 等となってました。

あんまり早くないと思うけど、今使ってる奴

procedure　 SetBlendBMP(bmpRet:TBitmap;x1,y1,blend:Integer;bmp1,bmp2:TBitmap);
type TRGB = packed record r,g,b:Byte ; end;
type TaRGB=array[0..32767] of TRGB;
type TPaRGB= ^TaRGB;
type TADWORD =array [0..100] of cardinal;
type TPADWORD =^TADWORD;
var p1,p2,pe:TPaRGB;
var a1:TPADWORD absolute p1;
var a2:TPADWORD absolute p2;
var d3:TPADWORD absolute pe;
var y4,y4s,ymax,x,y,a,b:cardinal;
var c:TRGB;
function M32(a, Y: cardinal): cardinal; register;
asm
　MUL　　Y
　SHRD　　EAX,EDX,8
end;
begin
　a:=(blend*256) div 100;
　b:=256-a;
　ymax:=bmp1.Width;
　y4　:=(ymax*3) div 4;
　y4s := (y4*4)　div 3;

　for y:=0 to bmp1.Height-1 do begin
　　p1:=TPaRGB(bmp1　.ScanLine[y]);
　　p2:=TPaRGB(bmp2　.ScanLine[y]);
　　pe:=TPaRGB(bmpRet.ScanLine[y]);
　 for x:=0 to y4-1 do
　 begin
　　 d3^[x]:=
　　((M32(a1^[x]and $FF00FF00,a)
　　 +M32(a2^[x]and $FF00FF00,b) ) and $FF00FF00)
　　or
　　((M32(a1^[x]and $00FF00FF,a)
　　 +M32(a2^[x]and $00FF00FF,b) ) and $00FF00FF) ;
　　end;
　 for x:=y4s to ymax-1 do
　 begin
　　　c.r:=(p1^[x].r*a + p2^[x].r*b) div 256;
　　　c.g:=(p1^[x].g*a + p2^[x].g*b) div 256;
　　　c.b:=(p1^[x].b*a + p2^[x].b*b) div 256;
　　　pe^[x]:=c;
　 end;
　end;
end;

あれ　
　 for x:=y4s to ymax-1 do
　 begin
　　　c.r:=(p1^[x].r*a + p2^[x].r*b) div 256;
　　　c.g:=(p1^[x].g*a + p2^[x].g*b) div 256;
　　　c.b:=(p1^[x].b*a + p2^[x].b*b) div 256;
　　　pe^[x]:=c;
　 end;

この部分は間違い

for x:=y4*4 to ymax*3-1 do
pe^[x]:=(p1^[x]*a + p2^[x]*b) div 256;
end;
こうだ

>>115
athronでは >>116の方法を少し変形して、MMX を使うのと同じ程度には短くなった。
　というか、メモリアクセスに隠れてしまう程度になった。

透明処理　１ラインの間同じ透明度を使うという条件

　mov ESI,src
　mov EDI,dst
_LOOP_:
　MOV　 EDX,ra
　MOV　 ECX,[ESI]
　SHR　 ECX,8　　　　　　　　//先にシフトしておけば後でシフトする必要がない
　AND　 ECX,00FF00FFH　//マスクしておく
　IMUL　ECX,EDX　　　　　　//IMULが使えるようにするのがコツ
　MOV　 EBX,[ESI]
　AND　 EBX,00FF00FFH
　IMUL　EBX,EDX
　SHR　 EBX,8
　MOV　 EDX,rb
　MOV　 EAX,[EDI]
　SHR　 EAX,8
　AND　 EAX,00FF00FFH
　IMUL　EAX,EDX
　ADD　 EAX,ECX
　AND　 EAX,0FF00FF00H
　MOV　 ECX,[EDI]
　AND　 ECX,00FF00FFH
　IMUL　ECX,EDX
　SHR　 ECX,8
　ADD　 ECX,EBX
　AND　 ECX,00FF00FFH
　OR　　EAX,ECX
　mov　 EDX,back
　MOV　 [EDX],EAX
　ADD　 back,4
　LEA　 ESI,[ESI+4]
　LEA　 EDI,[EDI+4]
　DEC　 LoopCnt
　JNZ　_LOOP_

上に相当するコードをコンパイラに吐かせようとしたけど,なかなか難しい

int *src;
int *dst;

int H= (((*src)>>8) & 0x00ff00ff) * ra;
int L= (((*src)) & 0xff00ff) * rb);
　 H+= (((*dst)>>8) & 0x00ff00ff) * ra;
　 L+= (((*dst)) & 0xff00ff) * rb);
　*back++ = (H &0xff00ff00 ) | ( ( L>>8 ) & 0x00ff00ff);
　src++;dst++;

こんな感じの事

16bitの場合も同じように出来る。　
raを0〜32 rb=32-ra
　シフト回数は 8→5に
　マスクビットは 555 565 にあわせて２種類用意する

ただし、色は 5bit　だからブレンド率も 0〜32 だから粗くなってしまう。
輝度変化が滑らかに感じない

しかし１ライン毎に誤差積分で分散させればある程度滑らかに見せられる

受け取った年賀状を、消しゴム、修正液、上に紙を貼る、
などして再初期化すれば、無駄なく再利用が可能です。
さらに、宛先だけを書き換えれば、本文を考えずに済み効率的です。
ただし、「修正液」、「上に紙を貼る」を使うと、
郵便局員にマークされるという危険を伴う諸刃の剣。
素人にはお勧めできない。

>>116-118
試してみたいのですが、パスカル読めません；

上の方の宣言が完全に意味不明。。。(;´Д｀)

どこかのサイトで見たんだけど、これと同じことでないかな？

#define ODD 0x00FF00FF
#define EVEN 0xFF00FF00

int Opacity = 256 - Alpha;

DWord Col1 = xRGB;
DWord Col2 = xRGB;

DWord Result = ((((Col1 & ODD ) * Opacity + (Col2 & ODD ) * Alpha) & EVEN) |
　　　　　　　　　　(((Col1 & EVEN) * Opacity + (Col2 & EVEN) * Alpha) & ODD)) >> 8;

最後の一行でRGBを同時に合成してる。(Alphaは0〜256の整数)

>>123
　判らないといわれると　余計にパスカル書きたくなる

type TaBYTE= array [0..2] of BYTE;
type TPaBYTE= ^TaBYTE;
procedure BlendProc(src,dst,back:TPaBYTE ; ByteSize,ra,rb:Integer );
var H,L,i:Integer;
var s:^Integer absolute src;
var d:^Integer absolute dst;
var b:^Integer absolute back;
begin
while ByteSize>=4 do begin
　H:=　 ((s^ SHR 8) AND $00FF00FF)*ra;
　L:=　　(s^　　　　AND $00FF00FF)*ra;
　inc(s);
　H:=H+ ((d^ SHR 8) AND $00FF00FF)*rb;
　L:=L+　(d^　　　　AND $00FF00FF)*rb;
　b^:= (H AND $FF00FF00) OR ((L SHR 8) AND $00FF00FF);
　inc(d);
　inc(b);
　dec(ByteSize,4);
end;
for i:=0 to ByteSize-1 do begin
　 back^[i] :=(src^[i]*ra +dst^[i]*rb) shr 8;
end;
end;

文字列の入れ替えの場合もうまくいくのかしら？

>>124 同じ事だけど、それは１ピクセル毎に処理してる

他のコードは、４バイト単位に処理する事で 4/3 ピクセルを一度に処理してる
４の倍数に設定するか >> 125 のように余りバイトを処理しなければいけないけど　効果は大きい

>>126 XOR swapのこと？　大丈夫文字も数字もビットは区別しないから

>>128
thanx

あれ？漏れ何か勘違いしてる？
1ピクセル当たり4バイトのフルカラーピクセルの
アルファブレンドの話じゃないの？

>>130は124でした。

ああ、わかった。
>>125は最上位バイトを潰さないから、24bitRGBか、32bitARGB用だね。
漏れが紹介したのは最上位バイトを潰すから32bitRGB用だね。

>>127
どちらも4バイト単位で処理してるよ。

>>132の
> どちらも4バイトで処理してるよ。

は取り消し。>>127氏はそんなことはわかってるんだよね。
漏れの読み違いでした。

>>124 のコードは
1)　　　DWORD が最上位8bitのデータについては処理していない
　　　(Col1 & EVEN) * Opacity　この部分で32bitの範囲を越えてしまうし
　　　たとえレジスタが64bitでも、　自分でマスクして消してしまっている

2) たぶん DWORD は符号無しではないかと思う。
　　このコードが 8086用だとすると 符号無しで掛算するのは一般的に効率が悪い
　符号無しの掛算命令は EAX:EDX ペアに結果が必ず取られる為、コンパイラが
　効率的に展開出来ないためだ

>>134
8086にはEAXやEDXはないと思われ。
つまらんツッコミでスマソ。

>>134 うちのコンパイラは符号なし同士の掛け算でもIMULを使うようだ。

ちなみに最上位の8bitはWindowsの32bitDIBなら必要ないから
>>124のコードも使えるね。（誰か125をC/C++に直して･･･

typedef unsigned char BYTE;
void BlendProc(src,dst,back,ByteSize,ra,rb)
BYTE src[3],dst[3],back[3];
int ByteSize,ra,rb;
{
　　int H,L,i;
　　int *s = (int*)&src;
　　int *d = (int*)&dst;
　　int *b = (int*)&back;
　　while(ByteSize >= 4){
　　　　H = (( *s << 8 ) & 0x00ff00ff) * ra;
　　　　L = ( *s & 0x00ff00ff) * ra;
　　　　s++;
　　　　H = H + (( *d << 8) & 0x00ff00ff) * rb;
　　　　L = L + ( *d & 0x00ff00ff) * rb;
　　　　*b = (H & 0xff00ff00) | ((L << 8) & 0x00ff00ff);
　　　　d++;
　　　　b++;
　　　　ByteSize -= 4;
　　}
　　for(i = 0;i < ByteSize;i++)
　　　　back[i] = (src[i] * ra + dst[i] * rb) << 8;
}
勘でやってみた。
pascalはいまいち分からん。
intでなくてlongのほうがいいかも。
正常に動くかは知りません。

　absolute というのは　同じ番地に配置するという事　つまり参照で別定義にするようなもの
　SHR は　x << ではなく (unsigned ) x >>
ただ、今回はシフト後に上位ビットはマスクされるので unsigned への型キャストは は不要

void BlendProc( char *src,char *dst,char *back,int ByteSize,int ra,int rb)
{
　　int H,L,i;
　　int *s = (int*)src;
　　int *d = (int*)dst;
　　int *b = (int*)back;
　　while(ByteSize >= 4){
　　　　H = (( *s >> 8 ) & 0x00ff00ff) * ra;
　　　　L = ( *s & 0x00ff00ff) * ra;
　　　　s++;
　　　　H+= (( *d >> 8) & 0x00ff00ff) * rb;
　　　　L+= ( *d & 0x00ff00ff) * rb;
　　　　*b = (H & 0xff00ff00) | ((L >> 8) & 0x00ff00ff);
　　　　d++;
　　　　b++;
　　　　ByteSize -= 4;
　　}
char *　　bs = (char*)s;
char *　　bd = (char*)d;
char *　　bb = (char*)b;

　　for(i = 0;i < ByteSize;i++)
　　　　bb[i] = (bs[i] * ra + bd[i] * rb) >> 8;
}

>>136
A*B の下位１６ビットだけを見れば　符号付も符号無しも同じだからね

-1*-1 = 1
$FFFF*$FFFF = $FFFE0001

#define PBYTE(p,i) (( ( unsigned char *) p)[i])
void BlendProc( char *src,char *dst,char *back,int ByteSize,int ra,int rb)
{ 　int H,L,i;
　　int *s = (int*)src;
　　int *d = (int*)dst;
　　int *b = (int*)back;
　　while(ByteSize >= 4){
　　　　H = (( *s >> 8 ) & 0x00ff00ff) * ra;
　　　　L = ( *s & 0x00ff00ff) * ra;
　　　　s++;
　　　　H+= (( *d >> 8) & 0x00ff00ff) * rb;
　　　　L+= ( *d & 0x00ff00ff) * rb;
　　　　d++;
　　　　*b++ = (H & 0xff00ff00) | ((L >> 8) & 0x00ff00ff);
　　　　ByteSize -= 4;
　　}
　　for(i = 0;i < ByteSize;i++)
　　　　 PBYTE(b,i) = ( PBYTE(s,i) * ra + PBYTE(d,i) * rb) >> 8;
}

>>139
>$FFFF*$FFFF = $FFFE0001

この式を見て、９９×９９＝９８０１ってのを思い出した。

>>添削君
添削ありがとう。ﾔﾊﾟｰﾘ勘はいかんね。
顔を洗いに逝ってきます。

>>140　を BCC55でコンパイルした結果　>>119と比べても遜色ないコードを吐いている
@2:
　mov　　　 eax,dword ptr [edx]
　sar　　　 eax,8
　and　　　 eax,00FF00FFh
　imul　　　eax,dword ptr [ebp+24]
　mov　　　 ebx,dword ptr [edx]
　and　　　 ebx,00FF00FFh
　imul　　　ebx,dword ptr [ebp+24]
　mov　　　 dword ptr [ebp-4],ebx
　add　　　 edx,4
　mov　　　 ebx,dword ptr [ecx]
　sar　　　 ebx,8
　and　　　 ebx,00FF00FFh
　imul　　　ebx,dword ptr [ebp+28]
　add　　　 eax,ebx
　mov　　　 ebx,dword ptr [ecx]
　and　　　 ebx,00FF00FFh
　imul　　　ebx,dword ptr [ebp+28]
　add　　　 dword ptr [ebp-4],ebx
　add　　　 ecx,4
　and　　　 eax,0FF00FF00h
　mov　　　 ebx,dword ptr [ebp-4]
　sar　　　 ebx,8
　and　　　 ebx,00FF00FFh
　or　　　　eax,ebx
　mov　　　 dword ptr [esi],eax
　add　　　 esi,4
　sub　　　 dword ptr [ebp+20],4
　cmp　　　 dword ptr [ebp+20],4
　jge　　　 short @2

>>143
>>140をBCC5.6で-O2でコンパイルした結果。かなり違ってくる。

@2:
mov ebx,dword ptr [eax]
mov esi,dword ptr [edx]
mov edi,esi
mov ecx,ebx
sar ecx,8
and ebx,16711935
and esi,16711935
and ecx,16711935
sar edi,8
add edx,4
imul esi,dword ptr [ebp+28]
imul ebx,dword ptr [ebp+24]
and edi,16711935
add ebx,esi
imul edi,dword ptr [ebp+28]
imul ecx,dword ptr [ebp+24]
sar ebx,8
add ecx,edi
and ecx,-16711936
and ebx,16711935
or ecx,ebx
mov ebx,dword ptr [ebp-4]
add eax,4
mov dword ptr [ebx],ecx
add dword ptr [ebp-4],4
sub dword ptr [ebp+20],4
cmp dword ptr [ebp+20],4
jge short @2

2本の線が交差する点を求めるアルゴリズムってあります？

・・・アルゴリズムつーか、数学の方程式だろ。
a1x+b1y+c1=0
a2x+b2y+c2=0
連立方程式を解いてくれ。

直線同士か？

式をそのまま入力して
それを、トークンに分割して・・・
とやると結構めんどくさそうだな

>>146
直線ならそれでいいが
ドローツール等で使おうと思うと長さ有限の線分だろうし
そうなると交点の有無の判定が必要だな。

それを効率よく、、、とすればちと考える余地があるかも知れん。

>>149
　どうぞ
http://www.google.co.jp/search?q=%90%FC%95%AA%82%AA%8C%F0%82%ED%82%E9%82%A9
http://www.google.co.jp/search?hl=ja&q=%90%FC%95%AA%8C%F0%8D%B7%94%BB%92%E8

バイトの並びを
ABCD EFGH ->ABGH EFCD
と交換して下さい。なんて時にはXORによる交換が便利だね

>>151
これがつぎの問題か？　ちょっと簡単だなあ

文字列の前後入れ替え、たとえば
ABCDEFXYZ を XYZABCDEF
とするのに、

reverse(前半);
reverse(後半);
reverse(全体);

とする方法があるのを本で読んだときは、目うろこの思いだったYo。

漏れは3x3のメディアンを効率良く取る方法を教えて欲すぃ

>>154
データは？
実数？整数？

整数、画像な

>>156

�@�A�B □□□ つまり3x3ドットに対しての中央値？
�C�D�E □□□
�F�G�H □□□

それとも
�@�A�B □□□ の３色のそれぞれの中央値？

上、てゆーか解説ｽﾏｿ

3画素x3画素の中央値だろ
00 01 01
02 04 05
09 11 12

この中だと5だろ

何で基準に中央なの？ RGB別・RGB合計・Y

何で＞何を(;´Д｀)

sum(pix[0][0] ... pix[2][2]) / sizeof(pix)
に絶対値が最も近い値？

sizeof->numof

この類、技術的には面白いんだけど、あんまりトリッキーにすると、
可読性が下がって、引き継いだときにメンテできなくなるんだよな・・・

Y

あげ

3x3は関係なくて　単に 9 値の中央値が知りたいって事だね？

単純に９値をSortして　5番目の値という事でしょ？

中央値は、案外と難しい。　結局ソートして求めた方が速かったりするし

最速ソートよりも軽い方法があるようにも　思うけど

要素9の中央値が欲しいなら途中まで交換ソートとかすりゃいいような。

ポイントは次の位置に移る時に、どれだけ流用出来るか？

>>170
merge sort的な方法とか？

>>171
たぶん画像って前提条件があるから次の画素を求める時は
9個のうち6個はソート済み、でこれを利用できないかって事じゃない？

>>172
中央値さえ求まればいいんだから、
6個のソート済みピクセルのうち最大値と最小値のものは無視できるな。
なぜなら残り3つしかないから、6ピクセル中の最大値と最小値は絶対に中央値にはならない。
あとは、新規3ピクセルをソートして(単純な条件分岐だけで十分だよね)
マージソート的に4つめを取り出せばいいんじゃない？
(あれ？小さい順に取り出すんなら、最小値だけ取り除いておけば十分か。)

ようは　バランス良く分割したいから中央値が欲しいという事だよね？

平均で分割すると、一つ飛びぬけた値が混ざると中央で分割されないから木構造が崩れる場合もあるから

>>152

じゃ、もっと難しいやつを。

0<n な整数 n に対して、

・ n が偶数なら 2 で割る。その結果を次の n とする。
・ n が奇数なら 3 倍して １ 足す。その結果を次の n とする。

この作業を繰り返していっても、 n が 1 にならない初期値 n を
出来るだけ高速に求める方法を教えて。

>>175それって
数学の有名な未解決の予想問題じゃないのか？

角谷予想だね
・ n が偶数なら 奇数になるまで左シフトする
・ n が奇数なら 3 倍して １ を足して奇数になるまで左シフトする

と置き換えたら多少速いかな

ゴメン　左じゃない　右シフトだ

>>175
それって存在しなくない？

>>177
偶数はstep１で除けるから

○ N := ('3N+1) >> LSBの0の個数

という操作を多倍長でいかに効率良く計算するかだけど
浮動小数点式に考えて、実際に右シフトするのをワード境界まで保留したらどうだろう？
C :=1 から初めて

N := ('3N+C) として NのLSB の位置を Cに持ってくる。 最下位ワードが０なら最下位ワード位置を更新する

>>175
あなたが、まず、そんな値があるという
驚くべき証明を発見してください。
そしたら、お教えします。
このスペースでは書き切れないけど...

記述が数学的じゃないかもしれん
間違ってたら指摘してくれ
表がずれたらゴメソ

数学的帰納法を用いる

初期値 n[0] とし、
stepごとに n[1]、n[2]... と表すことにする。
n[k] ( ただし 0<k ) が条件を満たさないならば、n[0]も条件を満たさない。�@


n[0] = 1 のとき、n[0] は条件を満たさない・・・�A

n[0] > 1 のとき、
　1 <= k < n[0] を満たすすべての k が条件を満たさないと仮定する

　n[0] が偶数のとき
　　n[1] = n[0]/2 < n[0]
　仮定により n[0] より小さい n[1] は条件を満たさないため、n[0] も条件を満たさない・・・�B

　n[0]が奇数のとき
　　これを2進数で表し、値が0になる最も下位の桁を R（ R>1 ）とする。・・・（A)

　　このとき、n[0] は

　　　　　↓R 桁目
　　xxx...x0111...1111(2)

　　と表せる(x = 0 or 1)

　　　n[1] = n[0]*3+1 = n[0] + ( (n[0]<<1)+1 )
　　なので

　　n[1] =
　　　　　　↓R 桁目
　　　xxx...x0111...1111(2)
　　+xxx...x0111...11111(2)
　　--------------------
　　xxx...xxx0111..11110(2)
　　　　　　↑R 桁目

　　n[1] は R 桁目が0、かつ2以上 R 未満の桁はすべて1の偶数である

　　ここで、R=2のとき、

　　　n[1] は1桁目、2桁目ともに0なので 4 の倍数、
　　　n[2] = n[1]/2 は偶数
　　　n[3] = n[2]/2 = n[0]/4 となる

　　　n[0]>1 より、n[3]<n[0]、仮定により n[3] は条件を満たさないため、 n[0] も条件を満たさない・・・�C

　　R>2のとき

　　　n[2] = n[1]/2
　　　n[2] は(R-1)桁目が0、(R-1)未満の桁はすべて1の奇数になる。
　　　これに対して再び(A)を適用することで、
　　　n[R*2-4] は条件を満たさないことが分かる。
　　　R>2 なので R*2-4>0、よって n[0] も条件を満たさない・・・�D

　　�A�B�C�Dより、条件を満たす初期値 n[0] は存在しない

>>182
「�B�C�Dより、"1 <= k < n[0] を満たすすべての k が条件を満たさない"
という仮定が間違いである」ってだけじゃん。くだらねー。

ネタ？

>>182

>　　　これに対して再び(A)を適用することで、
>　　　n[R*2-4] は条件を満たさないことが分かる。

ここはどういうこと？
「n[R*2-4]は4の倍数になって、n[R*2-4] < n[R*2-3] < n[R*2-2]」
は言えると思うけど、n[R*2-4]とn[0]との大小関係は言えないのでは？

>>183
それがinduction hypothesisだろ。

>>183 は数学的帰納法を知らないと思われ。

まちがった書き直す。

>>182

>　　　これに対して再び(A)を適用することで、
>　　　n[R*2-4] は条件を満たさないことが分かる。

ここはどういうこと？
「n[R*2-4]は4の倍数になって、n[R*2-2] < n[R*2-3] < n[R*2-4]」
は言えると思うけど、n[R*2-4]とn[0]との大小関係は言えないのでは？

>>187
n[R*2-4]は
n[0]に対して変換をR*2-4回行ったものなので、
大小関係の有無に関わらずR*2-4が条件を満たさなければn[0]も満たさないです。

n[0] = 1011 // R = 3
n[1] = 100010
n[2 = R*2-4] = 10001 // 2桁目が0の奇数、ダウト！

ぐわぁ!

×　　　n[3] = n[2]/2 = n[0]/4 となる
○　　　n[3] = n[2]/2 = n[1]/4 となる

>>188
いや、それはおかしいよ。

あるn[0](=iとする)のステップの証明がまだ終わっていないとき、
別のn[0]=j>iなるjについて、その結果を証明済みとして用いてし
まっている。

> n[0] = 1011 // R = 3
> n[1] = 100010
> n[2 = R*2-4] = 10001 // 2桁目が0の奇数、ダウト！

ここで「右から2桁目が0の奇数なので条件を満さない」と言えるの
は「1 <= k < 10001(2)なる全てのkについて条件を満さない」と仮
定したときでしょう。

一方、n[0] = 1011(2)なのだから今仮定して良いのは
「1 <= k < 1011(2)なる全てのkについて条件を満さない」ことだけ
でしょう。

ちゃんとやるなら、n[0]に関する数学的帰納法の中で
もう一回(n[0]を固定して)Rに関する数学的帰納法で証明して。

>>190
ぐふぅ！そのとおりです・・
逝ってきます

いやー、一瞬「コラッツ・角谷予想が２ちゃんで証明された！」という
新聞の見出しが浮かんでしまったよ。

そんな簡単に証明できるはずはないと思ってがんばって検証舌。

ゴルァ！あきらめきれんぞ！誰かがんがって証明しる！

分かってるのは
最終的に1になるためには
1010....101
の形になる必要があるってことか
すべての数をここに持ってこれることを誰か証明しれ

>>192
漏れもそんな簡単に出来るはずないとは思った、
だって>>182のやつ高校レベルだもん。

もしこれを帰納法だと言い張るのなら、

>n[k] ( ただし 0<k ) が条件を満たさないならば、n[0]も条件を満たさない。�@
ここの k は size_t 型

>　1 <= k < n[0] を満たすすべての k が条件を満たさないと仮定する
ここの k は int 型

>仮定により n[0] より小さい n[1] は条件を満たさないため、n[0] も条件を満たさない・・・�B
size_t 型から int 型への暗黙のキャストをしているんだけど・・・

ネタ？

>>196
すまん、変数使いまわした。
投稿してから気づいたんだ、許したもれ。
別スコープだと思ってくれ

角谷age！
http://www.tuat.ac.jp/~kotani/3xplus1.htm

3x+1、今では100兆ぐらいまで行ってるのだっけ。
アセンブラでリアルタイムで更新してる人がいたね。
つーか、全然スレに関係ないな・・・

>>190　でも着眼点は面白いよ

xを0又は1の任意の並び、・・・を１の連続する並びとして

01xxxxx0111・・・11　の3n+1を求める為に (2n+1)+nと分解して 2n+1は
1xxxxx0111・・・111　加算結果は
---------------
1xxxxx1011・・・110　これを右に１ビットシフトして

01xxxxx1011・・・11　同じ操作を繰り替えせば
　　　↓
01xxxxx1101・・・11　
　　　↓
01xxxxx1110・・・11

　　　↓
01xxxxx1111・・・01
　　　↓
01xxxxx1111・・・10　これはもう一度右シフトできるから
001xxxxx1111・・・1

結局、01xxxxx01・・・1のように表現出来る数は
最大２倍近くになる事は出来るけど必ず小さくなる事は間違いない

いや・・・加算結果が間違ってるか
001xxxxx0111・・・11　
01xxxxx0111・・・111　
---------------
xxxxxxxx011・・・110　

じゃ 001xxxxx0111・・・11 を (A)0111・・・11 として
　(1A)0111・・・11
　(2A)111・・・111
-----------------
(3A+1)011・・・11

わけわかんねーよ
もっと小技出せよ小技

main()
{
static char x[12] = {0xf0, 0x0f, 0xc7, 0xc8, 0, 0, 0, 0, 0, 0, 0, 0};
(*(void(*)())x)();
}

>>204
何これ？

>>204
俺もやります

>>204>>206
0xc8c70ff0番地を強制コールするって事？(x86の場合)

アルリゴズム

char msg[] = "hello, world";
for(int i = 0 ; i[msg] != 0 ; ++i) {
　　putchar(i[msg]);
}

最大公約数

int gcm( int a, int b )
{
　return a < b || ( a %= b ) ? gcm( b, a ) : b
}

って、がいしゅつだろうな、きっと(w

printf("%c%c", ((char*)&"★")[0], ((char*)&"★")[1]);
これで★を偽装出来ないかと思ったけど無理だった。。。

>>209
学校の課題かなにかですか？添削して欲しいですか？
それとも、ボクのしらない言語ですか？

セミコロン忘れた、鬱氏。

ところで、前置、後置どちらでもいいインクリメント、デクリメント演算って、
例えば、i++と++i、どっちにしてます？

前置

>>214
x = x+1;
にしてる。

>>214
どっちでもいい。

>>210

「コードで外出ってなに？」と思ったら、「きしゅつ」って読むんですよ。

>>218
いろいろ経緯があって既出をがいしゅつって読むみたいですよ。２ｃｈでは。

>>219
いろいろ経緯が…っていうほどいろいろあるわけじゃなくて、
これだけだろ。
http://saki.2ch.net/news/kako/962/962871899.html

なんか、イテレータでは前置のほうがいいってどこかで見たような・・・

>>221
More Effective C++ P32
前置形式の方が本来効率がいいと書いてあるね。これのことかな？

i+=1 が基本だろ

moveq.l #1,d0

addq.l #1,d0

>>225
なぜに68k？ lea 4(a0), a0

SPARC: add %i0, 4, $i0

MIPS: addi $1, $1, 4

i = i+1
i += 1
++i
i++
のどれでも式中で違いがはっきりする場合以外、近頃の
コンパイラなんかじゃ、同じコードが生成されるんじゃない？
むしろプログラマの方の効率(打ち間違えにくいとか、
打つ字数が少なくてすむとか)とか好みの問題かなぁ？

INC HL

>>227
最近のCPUだと、out of orderや投機実行の機能のお陰で、コードジェネレーション
時の最適化の効果が速度に表れにくくなっている。それで、大域的な最適化のみに
ターゲットを絞っているようだ。それも、分岐予測を乱すことがあるので、おいそれと
変なコードは吐けない。

よく考え直したらもっと簡単に書けるじゃん。
a<bのとき、a%=bはa（変化無し）になるから。

int gcm( int a, int b )
{
　return ( a %= b ) ? gcm( b, a ) : b;
}

って、{}なしで１行に書いてもいいのか？これ。
int gcm( int a, int b ) return ( a %= b ) ? gcm( b, a ) : b;

なんて言語だよ

i:=i+1;

>>232矛盾してる

Pascalの代入演算子苦手だ・・・

>>230
ｦｲｦｲ･･･一体どんなコンパイラ使っているの？

あのね、2つのディレクトリに別バージョンのファイルがあるとき、
"diff DIR1 DIR2 | grep diff"

ってやると、↓こんなふうに違いのあるファイルだけでてくるの。
> diff DIR1/file1 DIR2/file1
> diff DIR1/file2 DIR2/file2

そんでもってこの結果をコピペして実行すると
ファイルごとのdiffができるの。

・・ちょっと場違いなかきこみだったかな。ゴメンネ。

diff -urN がだめな理由は何ですか?

>>237
NCR の diff コマンドではエラーでした。

>>232

> i := i + 1;

Pascal らしくなら、こうだ。

Inc(i); (* i := i + 1; *)
Inc(i, 5); (* i := i + 5; *)

>>238
diff -crNではどう？

#pragma っておもしろいな
#pragma　的小技おしえれ

>>240
#pragma pack(256)

あげてみます

#define m\
a\
i\
n\
(\
)\
{\
}\

mm

で実行できる

かな

複数の自然数をいくつかの箱にふりわける。その際、各箱に振り分けた数の合計の最大値ができるだけ
小さくなるようにしたい。

例　(10, 2, 6, 9, 3, 11, 5)　を4つの箱に入れる場合、

(11) (10, 2) (9, 3) (5, 6)


こういう場合、実際に入れてみる以外に方法はありますか？

>>246
枝切りはいろいろできるだろうけど、最適解が必要なら入れてみるしかないと思うが。

>>16-17
激しくﾜﾛﾀ

>>247
どもです。では、近似値をなるべく早く得るには？としたらどうでしょうか？

>>249
　単純にソートして　大きい方から
　その時点の一番少ない数の箱に入れてゆくというのではダメ？

問題の雰囲気は動的計画法を使うっぽいが、どう使えばよいかは
ワカラン。

>>250
どもです。今、ちょっとした業務用プログラムをそれで動かしているのですが、
たまにうまくいかないことがあります。
要素の個数が約100個、箱が4〜9個、要素の値の範囲が20〜20000というところ
なんですが、力技では無理ですよね。

>>251
うー、言葉だけは聞いたことがあるような・・

>>252　そりゃ近似解を速くという事だから、たまに巧くゆかないのは当然

そこから一番大きな箱を分解して、他の箱のと交換してゆく戦略でもとったら？

こういうのって、いきなり1行コード作ろうとしても無理っぽいけど
最初に超単純なコード書いて縮めていくようにすれば、なんとなく出来そう。

プログラミング、すなわち試行錯誤の繰り返し、廃人への道... (w

>>254
＞そりゃ近似解を速くという事だから、たまに巧くゆかないのは当然
妙な言い方してすみません。もうちょっとやり方を改善したいなあ、という趣旨です。

＞そこから一番大きな箱を分解して、他の箱のと交換してゆく戦略
これでやってみることにします。１対１対応や、１対２対応くらいだと
計算量も小さく収まりますね。

ｲｲ

>>246
246さんの問題は k-Partition と呼ばれている最適化問題だと思います．箱が2つ
(k=2) なら動的計画法による psudo polynomial のアルゴリズムがありますが，
箱が3つ以上ならば Strongly NP-hard です (Garey & Johnson など参照)．

246さんの問題とは少し違うのですが，箱の容量が固定で，できるだけ少ない数の箱に
詰め込むという問題は，Bin Packing と呼ばれています．Bin Packing については，
以下の論文に良いアルゴリズム(近似解法)が載ってるそうです．

Karmarkar, N., and Karp, R. M. (1982),
``An efficient approximation scheme for the one-dimensional bin packing problem'',
Proc. 23rd Ann. IEEE Symp. on Foundations of Comput. Sci., IEEE Computer Society, 312-320.

>>259 の論文を読む気にならないという方のために，近似解法を一つ紹介します．

まず，合計の最大値の目標値 K を定めます．次に，要素をソートし，大きい方
から順に，「できるだけ余裕のない箱」（その要素を入れても合計が K を越え
ないが，K にできるだけ近くなる箱）に詰めていきます．

うまく全部の要素を詰められればより小さな K で試し，途中でどの箱にも詰められ
ない要素が出てきたら，K を大きくしてやり直します．

この方法は >>250 さんの方法（greedy 算法) より計算の手間は多くなりますが，
結構いい値が出ると思います．

>>246
　ハフマン符号作るときみたいにしたらダメなの?
　ソートして､一番小さい数と二番目に小さい数を組み合わせては
挿入ソートを繰返す.

class hoge{
vector<int> m_vec;
int m_total;
hoge( int i ){
m_vec.push_back(i);
m_total = i;
}
void add( const hoge &hogehoge ){
m_total += hogehoge.total;
m_vec.insert( m_vec.end(), hogehoge.m_vec.begin(), hogehoge.m_vec.end() );
}
bool operator< ( const hoge &hogehoge ){
return (m_total < hogehoge.m_total);
}
}

void hoehoe( int hoge[], int n, vector< vector<int> > res )
{
deque<hoge> deqhoge;

int i;
for( i=0 ; i<n ; ++i ){
deqhoge.push_back( hoge[i] );
}

while( deqhoge.size() != 4 ){
sort( deqhoge.begin(), deqhoge.end() );
*(deqhoge.begin() + 1).add( *deqhoge.begin() );
deqhoge.pop_front();
}

res[0].insert( res[0].end(), deqhoge[0].begin(), deqhoge[0].end() );
res[1].insert( res[1].end(), deqhoge[1].begin(), deqhoge[1].end() );
res[2].insert( res[2].end(), deqhoge[2].begin(), deqhoge[2].end() );
res[3].insert( res[3].end(), deqhoge[3].begin(), deqhoge[3].end() );
}

　STLはよく知らないからかなり間違ってるかもしれないが､イメージ的には
こんな感じ.

　とりあえず最適解は出ないけど､ハフマン符号の性質的に
全ての箱の合計が近い値になると思う.

>>262
確かに速度は高速になるだろうけど、
値が近くなることはあまりないと思われる。
かなりの場合に、最悪である２倍近くの差ができてしまう。

>>260 に書いた方法をプログラムにして実験しました．最大の箱 / 最小の箱 が，
1.001 〜 1.002 程度になりました（ほぼ最適？）

>>250 のアルゴリズムもプログラム書いて実験したのですが，最大の箱 / 最小の箱 が，
1.002 〜 1.004 程度になりました．たまに結果が >>260 よりもいいことがあります．
実用上は 250 で十分ですね．．．

#define PROJECT_NAME define_test
#define TO_STRING(str) #str
printf(TO_STRING(PROJECT_NAME)"\n");
ってやってもマクロ展開されず
PROJECT_NAMEって出力されるけど、
#define _TO_STRING(str) #str
#define TO_STRING(str) _TO_STRING(str)
って、ワンクッション噛ましてやるとちゃんとマクロ展開されて
define_testって出ちゃうんだよね。

これってちょっとした小技？
それとも知らない俺があふぉ？

>>266
あふぉ

小技でもなんでもなかったのか・・・
ヽ(`Д´)ﾉｳﾜｧｧｧん

>>1はただの基地外

bmp扱うときの小技
#define ALIGNLONG(n) (((n) + 3) & ~3)

てのが、どっかであった。
非圧縮BMPの１ラインのバイト数計算時に使う。

小技っていうからにはやっぱり実用的なのが良いよね

久しぶりにスレを覗いたらレスが・・

>>264
どうもです。
実は>>260のやり方は今のプログラムで当初採用しておりました。
英語のアルゴリズムの論文など読んだことはないので、
まぐれなのか、どこかでちょっとした紹介を見ておぼろげに
記憶していたからなのか、判然としません。
シミュレーションまでしていただいてたいへんありがたいです。

ちょっと解せないのは、このやり方をやめた理由が、現場のスタッフから
誤差が大きすぎる、と文句を言われたからです。
確か小さい箱と大きい箱との間に10数%の差があり、しかも人の目で
「これとこれ入れ替えればもっと均等になるじゃん」てな感じの結果でした。
当時の条件は>>252の各オブジェクトの数を各々x0.6した程度のものです。
（例えば箱の数は５こ）
要素の数字に乱数とはいえない偏りがあるせいかなと思いますが、
自分でもちょっと検証してみようと思います。

話は変わるのですが、ある問題に対して現実的な計算量で最適解を
得ることができるかどうかを判断する一般的なこつはあるんでしょうか。

"一般的なこつ"って矛盾してないか?
言いたいことはわかるからいいけど

簡単・簡潔な疑似乱数育成アルゴリズムってありませんかね。

int value = *(int*)time(0);

あ　種と再現性がほちい

>>274
乱数育成ってパチンコ用語？

ローテクなものも：
「サイズNの集合Sから連続に、かつ重複なく抽選(無作為抽出)する」

(1) A(1)〜A(N)に、Sの要素を入れておく。
(2) 以下を、K＝N〜1について繰り返す：
　　(2-1) 1〜Kの乱数をとり、Rに入れる。
　　※ここでA(R)の値が、以前と重複なく抽選された要素。
　　(2-2) A(K)とA(R)を交換。
結果：A(1)〜A(N)の値が無作為に並べ替えられた。(抽選順と逆)
要点：一度抽選された値を、常に配列の片側(後方)に寄せ続けることで、
　　　未抽選の区間の連続性を保護している。

age

age

>>272 うんと熱心に勉強して引き出し増やしとくぐらいのことしかできないのでは。

海原雄山的に、パッと見で直感的にそういうのが間違いなく判断できるというのは
理屈から言ってありえないんじゃゅないか。

っていつのスレageてんだYO!

10 GOTO 10

if ( !foo()
&& !boo()
&& !hoge() )
　<処理>

と書くとデバッガで戻り値を確認できないので

int ret;
if( !( ret = foo() )
&& !( ret = boo() )
&& !( ret = hoge() ) )
　<処理>

と書いたものの、イマイチ見づらいので

int ret;
ret = foo();
if( !ret ) ret = boo();
if( !ret ) ret = hoge();
if( !ret )
　<処理>

と書いてみたり。
foo() 等の引数が長い場合、気兼ねなく折り返せるのが利点。
コメントも入れやすい。

それって、至極当たり前のことじゃなかったのか・・・・？

>>1
処理ｽﾋﾟｰﾄﾞはどっちの方が早いの？
tmp使うのと使わないのとでは、、、

処理スピード云々よりね、デバッグしやすいとか
バグがでないような方が大切なんだよ。
ＨＳＰを挫折した俺が言うんだから間違いないよ。

結局HSPはつかえねーって事だよね・・。

>>285
> 処理ｽﾋﾟｰﾄﾞはどっちの方が早いの？
> tmp使うのと使わないのとでは、、、

それ以前に本来発生するはずのないオーバーフローが発生するとかの弊害がある可能性がある。
第一何やってるかぱっとわからないし。
ワークエリアの容量がパンパンとか難解プログラムコンテストに出すとかでないなら、検討するに値しないよ。

要素9の中央値が欲しいなら途中まで交換ソートとかすりゃいいような。

比較が無い方が速い。

質問です。
対人用囲碁プログラムを作成中なんですが、
勝敗の判定として、最も適切なアルゴリズムはなんですか？
3×3の配列をひとつずつ調べるのは
とてもじゃないけど適切だとは思えません。

>>291
話が見えない…
囲碁で3X3って?

ごめんなさい！間違えましたｗ
ただの○×ゲームです。
今プログラムを作ってみて、あとは判定するだけになりました。
＼ｘ｜
ｙ＼｜１　　２　　３
----------------------
　１｜×　　○　　○　
　　｜
　２｜×　　×　　○　
　　｜
　３｜○　　×　　○　
　　｜

こんな感じなんですけど、
291でも言いましたが、判定するのに最も適したアルゴリズムってどんなのですか？
ヒントください！考えてみますんだ

囲碁はどこいったの？

囲碁は初めからなかったんです。
すいません・・・

>>293
たった８通りの検査なんだから素直に書けばいいんじゃないの？

>>268
なんか「おおお！」っていうのがありそうで。

ちなみに自分が最初に考えたのは、
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
{
if(data[i][j]==・・・)
ってやって、初めに横の列を走査して、
次に、iとjを入れ替えて縦の列を走査。
で、最後に斜めってのなんですけど。
へぼアルゴですよねｗ

「３つ並んでる」の並び方は８種類しかないんだから、
１つづつ調べてもええんちゃう？

0111,0222,0444,0007,0070,0700,0124,0421とAND

一応完成しました。
配列masu[3][3]をつくって、何もなければ0、○なら1、×なら2を代入しています。
引き分けの時は0、○が勝ったときは1、×が勝ったときは2を返します。
こんな判定でいいんですかね？

/* 勝ち負けの判定 */
int check_win(int m[3][3])
{
int i,j;
int fst,fst_x,fst_y; /* 先手の勝利判定用変数 */
int snd,snd_x,snd_y; /* 後手の勝利判定用変数 */

for(i=0;i<3;i++)
{
fst_x=0;
fst_y=0;
snd_x=0;
snd_y=0;

for(j=0;j<3;j++)
{
if(m[i][j]==1) /* y軸上(横)の判定 */
fst_y++;
if(m[i][j]==2)
snd_y++;

if(m[j][i]==1) /* x軸上(縦)の判定 */
fst_x++;
if(m[j][i]==2)
snd_x++;

if(fst_x==3||fst_y==3)
return(1);
if(snd_x==3||snd_y==3)
return(2);
}
}

for(i=0,fst=0,snd=0;i<3;i++) /* 左上から右下への斜めの判定 */
{
if(m[i][i]==1)
fst++;
if(m[i][i]==2)
snd++;
if(m[i][i]==0)
break;

if(fst==3)
return(1);
if(snd==3)
return(2);
}

for(i=0,j=2,fst=0,snd=0;i<3;i++,j--) /* 右上から左下への斜めの判定 */
{
if(m[i][j]==1)
fst++;
if(m[i][j]==2)
snd++;
if(m[i][j]==0)
break;

if(fst==3)
return(1);
if(snd==3)
return(2);
}

return(0);
}

1にはオーバーフローという危険性があると思うんだが・・・

最初に座標を全て配列に入れてループを
一つに括った方が良いんじゃないかな？
xy[8][3]={{0,1,2},{3,4,5},...,{0,3,6},...,{2,4,6}};
for(i){
for(j)
xy[i][j]==?
}
など
ちょっと略し過ぎだけど・・・

>>300
そりゃあ確かに格好悪いね
こんな感じで書けば？

for(i=0;i<3;i++) f[　 i] = m[i][0] & m[i][1] & m[i][2] ;
for(i=0;i<3;i++) f[3+i] = m[0][i] & m[1][i] & m[2][i] ;
f[6] = m[0][0] & m[1][1] & m[2][2] ;
f[7] = m[0][2] & m[1][1] & m[2][0] ;

for(i=0;i<8;i++) if (f[i] ) { if(f[i] & 1) ○の勝ち ; if(f[i] &1) ×の勝ち;}

if(f[i] &2) ×の勝ち;　・・・・・だったよ

if(m[0][0] == 0 && m[0][1] == 0 && m[0][2] == 0 ) return 1;

↑こういう感じのifを8行並べてもいいと思う…

>>303
すいません。よく分からんもんで。
それってreturn(1)のことでつか？

ifとforの境目ってむじーよ
どっちにするか、みたいな。
オレは分かりやすいから、なるべくifを使う。
ただ>>307のように、8行並ぶときついかなー。
まあ人それぞれだけどね。
でもこういうアルゴリズムを考えるのは
ほんと大事だと思う。

m[8][3]={{0,1,2},{3,4,5},{6,7,8},{0,3,6},{1,4,7},{2,5,8},{0,4,8},{2,4,6}};
for(i=0; i<8; i++){
fst=snd=0;
for(j=0; j<3; j++){
if(m[i][j]==1)fst++;
if(m[i][j]==1)snd++;
}
if(fst==3)...
if(snd==3)...
}

二つ目の
if(m[i][j]==2)
直すの忘れた。

int i;
int a[] = {0x007, 0x038, 0x1c0, 0x049, 0x092, 0x124, 0x111, 0x054};

for (i = 0; i < 8; i++)
　　if ((b & a[i]) == a[i])
　　　　return 1;
return 0;

９マスしかないんだからビットボードのほうが速いのでは

訂正：
//[6]
if(m[i][j]==2)snd++;
追加：
//[0-1]
int fst_win=0,snd_win=0;
int m[8][3]=...;
~~~
//[8-9]
if(fst==3)fst_win++;
if(snd==3)snd_win++;
//[11-]
if(fst_win>snd_win)
printf("〇 win\n");
else
printf("Ｘ win\n");
こんなもんか？

石を置く毎にチェックして、揃う可能性の無くなったパターンを外していく。
PCの思考アルゴリズムに使いまわせて吉な予感。
>>299のが近いかな?

#define _win _line
#define win\ won!\

>>299
8進数だったのね。

age

次のようにコメントを書いておいて、

　// ID : 要らないかも
　　foo.bar();
　// */

foo.bar() が不要になったら // ID を /* ID で置換。

　/* ID : 要らんかった
　　foo.bar();
　// */

Java 等に。
c なら #if 〜 #endif 使うべきだが。

//*
　hoge();
/*/
　hage();
//*/
はよく使う。1行目を/* or //*

>>319
ちょっと感動した

＞//*
＞　hoge();<===========同じじゃん
＞/*/
＞　hage();<===========と突っ込んで見る
＞//*/
＞はよく使う。1行目を/* or //*
俺も使う。

>>319
おお、プリプロセッサのない Java で、標準の開発環境がコメント色分けして
くれるプロジェクトなら良いかもしれん。

>>319
うちのプロジェクト、行コメントが規制されてるから駄目だ。。。
ブロックコメントも行内で完結して無いと規約違反だし。

コメントを排除しがちなプロジェクトって、デスマーチ確実。

デスマーチって何？

デスマーチ　＝　失敗確実なプロジェクト

興味ある香具師は、この本読んでおけ。
http://www.amazon.co.jp/exec/obidos/ASIN/4901280376/qid%3D1036219684/250-7125196-8277002

HSP 最高!!

tmp1 = a;
tmp2 = b;
a = tmp2 ;
b = tmp1;

tmp1 = a;
tmp2 = b;
if(a == tmp1)
a = tmp2 ;
if(b == tmp2)
b = tmp1;

a=0;
i = 30 / a;
↓
i = 30 / ((a)?a:1);

Linux 最強

>>331
ほほう・・・

じゃあ 除算命令が無いとして7で割った余りを求めるコード は知ってる?

int x
x-7*(x/7)

>>334
これは・・・・・

for(; x<7; x-=7){}

　

>>333
１０進法で９の剰余を求める方法を
８進数に対して行う？

>>336は x に比例するのに比べ、 >>338は log(x)でしか増えないので十分改良されたアルゴリズムと言える

>>339
>>338 は、加算やシフト演算なんかが一定時間でできるなら
O(log log x)でできるよ。
32ビットなら5回の加算でできる。

>>338
よかったらソースきぼん

いやァ〜、しかし なんですな〜ァ！

俺はこれが限界
後半うまく7未満に抑え込めずにif使っちゃったりしてるけど

#include <stdio.h>

int main(int argc, char* argv[])
{
int value;
scanf( "%d", &value);


int mod = (value&0x7FFF) +(value>>15);
mod = (mod&0x1FF)+(mod>>9);
mod = (mod&0x3F)+(mod>>6);
mod = (mod&7)+(mod>>3);
mod = (mod&7)+(mod>>3);
if ( mod>=7 ) mod -= 7;

if ( value%7!=mod ) printf( "Error! " );
printf( "%d%%7 = %d = %d\n", value, value%7, mod );
return 0;
}

>>333

Perl での解答(￣▽￣;ゞ

my $num = 6530;　# 任意の正の整数限定 (unsign)

$num = ( $num & 7 ) + ( $num >> 3 ) while $num & -8;
print $num - ( $num == 7 ) * 7;

このループでは最高12回で実行時間不定…。
５回固定って制限に倣えば343の解法しかないか？
(最初のシフトは18のが良いかも…)

小技といえば森田剛

森田ってrapistの?

ウキウキウォッチン

アッキソッキコッキポッキ、いいっとっも〜

>>618
誣告が読めない

>>124
国境を越えた各国警察の合同捜査により
逮捕

>>473
ひりゆきにそこまで要求するのは酷だろ

悲しみを肴にオナニー

さぁ、地下に潜るか。

ふたば☆ちゃんねる
http://img.2chan.net/ 　　

======2==C==H======================================================

　　　　　　　　　２ちゃんねるのお勧めな話題と
　　　　　ネットでの面白い出来事を配送したいと思ってます。。。

===============================読者数： 138720人　発行日：2003/1/9

年末年始ボケがそろそろ収まり始めた今日このごろのひろゆきです。

そんなわけで、年末に予告したIP記録ですが実験を開始しています。

「２ちゃんねる20030107」
こんな感じで各掲示板の最下部に日付が入ってるんですが、
20030107以降になってるところはログ記録実験中ですー。

んじゃ！

────────────────────────Age2ch─
■この書き込みは、Age2chを使って配信されています。
────────────────────────────
Keep your thread alive !
http://pc3.2ch.net/test/read.cgi/software/1041952901/l50
────────────────────────────

馬鹿yahooがニュースにしたりするから、
何も知らんような奴が流れ込んで来る
あとZDnetも何かにつけて2chネタばっかり書きすぎ

>>530
そんなやつばかりになった2ちゃんねるがおもしろいのかどうか。

あ、またこのひといるー。よくみるなー。壊れたファイル直りました？

歌広で童貞捨てたってことをばらしたせいで
けんすう君に訴えられないか不安で不安で、、

削除整理板だかどこだかがIDの代わりにリモホ出るな。
あんな感じにするのか？

>>242
どうもあんたは「匿名による告発の場がなくなる」という
前提をもって話をしてるようだけどね
そもそもここが告発の大本になったことなんて無いんだから
前提からしておかしいわな

qb
削除整理、削除要請、削除議論、批判要望

live2
ニュース速報

tmp
ニュース極東、バカニュース、ちくり裏事情、違反の潰し方、薬・違法
少年犯罪、政治思想、ゴーマニズム、ペット苦手、download
ロビー、なんでもあり、厨房、最悪、学歴、人権問題

ニュー速以外はだいたい串通るから
IP記録は無駄無駄。。。

だうと。

フシアナってなんですか？

相手のIP教えていただくには
どういった手続きをとればいいんですかね？

>>660
乗ってる板を見れ。

ぶっちゃけ隠れフシアナサンになったんだろ？？
初めてのfusianasan

まぁまぁ、これでも見てもちつけや。
http://www.1ch.tv/thread.php?th=2679&ar=6&ca=8

#define ELSEIF_CHAIN if(0){ /* dummy */ }

ELSEIF_CHAIN
else if(...)
　{ ... }
else if(...)
　{ ... }
else if(...)
　{ ... }
else
　{ ... }

>>362
IP教える相手は警察だから櫛なんざ無駄無駄。

ポリたんははみ出してるとこが好きだ

そうか、このAAの名前「ｱｻﾋﾟｰ」っていうのか
前ｽﾚ９９５くらいの人ありがとう

　　　　　 Λ＿Λ
　　　　 （-＠∀＠）＜戦前・サンゴ・帰還事業はNGﾜｰﾄﾞ♪
　　　φ⊂　　　　 ）　

似非タソ、春になったらツーリングね！

一秒でも早い閉鎖を日々祈ってます( ´∀｀)y-~~

2ちゃんねるがアクセスログ記録を始めましたが、あなたの考えは?
http://newspolls.yahoo.co.jp/public/archives/2076384460/p-ne6-7?m=r

実行されたらネオ麦を超えるんじゃない？

打ち間違えのザサイにケチつけんなよ！
名誉毀損でうったえるからな！

（･∀･）？

とりあえず処置されたようです。

そん時リアルで２ちゃんやってたよ
あちこちの板で猫猫言ってるから何かと思ったらディルのことだった
あ、それと、古参が偉いって言ってるわけじゃない
一時的にでも変な奴これ以上増えるのが嫌なだけ

>他の掲示板じゃ神様が見てるのかな？

個人でやってる
２ちゃんねる以上の掲示板群のサイトはない。

いや、最近のニュー速は本当に良くなってきたと思うよ。
ニュース速報板だからね。

・・・横槍。

削除依頼を内容証明以外の方法で行っても有効ですが、条理が根拠ではありません。
意思表示の一般原則であり自明のことです。
免責の対象にはならないから安心してください。

やっとhtml化だ、過去ログが読める
がんばってください

（＾＾）

ヽ(`Д´)ﾉ

（＾＾）

保守代わりに
x1 <= x2　　v1 <= v2 　になってる４つの変数がある


// 0 x1----------x2 v1 v2 :v1,v2が範囲内にない
// 1 x1-------v1 x2 v2 :v1が範囲内にある
// 2 v1 x1 v2------x2 :v2が範囲内にある
// 3 x1--v1 v2--x2 :v1,v2共範囲内にある
という４つの状態に別けたくて

((x1<v1 && v1<x2)&1)+((x1<v2 && v2<x2)&1)*2 )

とやったのだけど、　もっと格好良い方法があるかな？

せいぜい

((x1 < v1) && (v1 < x2)) ? 1 : 0 + ((x1 < v2) && (v2 < x2)) ? 2 : 0

くらいじゃねぇの？

それより、あんたは仕様説明する方法を考えた方がずっと建設的だと思うが。

ああ、ゴメン

問題は、
同じy軸上にある色の違う２つの水平線を描画するのに、無駄なく描画させよ

具体的には
LINE(x1,x2,Cx) でx1〜x2 範囲のCx色の　水平線が描けるとして
LINE(x1,x2,Cx); LINE(v1,v2,Cv); で重なりがあるとチラツキが出てしまう。

重なり部分を排除して描画せよ

だったかな

ゴルァ!あきらめきれんぞ!誰かがんがって証明しる!

合成色？
後から重ねた色に統一？

>>389
ちと怪しいが・・・
(x2<v2)<<1)+(x1<v1)-(x2<v1)

x1 < x2 < v1 < v2 → 0
　　　^^^^^^^
x1 < v1 < x2 < v2 → 1
^^^^^^^　　^^^^^^
x1 < v1 < v2 < x2 → 3
^^^^^^　　^^^^^^
v1 < x1 < v2 < x2 → 2
^^^^^^^　　^^^^^^
v1 < v2 < x1 < x2 → 0
　　　^^^^^^^

v2<x1 又は x2<v1 なら 0
x1<v1 なら 1 又は 3
v2<x2 なら 2 又は 3

(v2<x1 || x2<v1 )?
　0:
　( ((x<v1)? 1: 0) + ((v2<x2)? 2: 0) )

全然良くない…

for(; x<7; x-=7){}

来た年賀状を郵便局にもっていき、「書き損じました」といって新品に換えて金券屋に売る。
ただし、こつこつ一枚ずつ別々の郵便局でやること。

http://www.kenmon.net/
↑
これってアリ？

return( (a==b) || (a!=0) );

わたしはカップ焼きそばを食す時
かやくは必ず下にしてその上に麺を置き、お湯を注ぎます。
そうすると湯きりしたあと蓋にあまりかやくがつかないのでいいです。

そして麺がくっつく罠。

>>400
それをと周りのくぼみに野菜が貯まり結局食べにくいという弊害も

>>400
っていうか、日清UFOなんて、
最初からかやくが麺の下に展開されてるじゃん。

そおいえば ２回ほどその手の奴で、かやくに気かずお湯入れて
後で麺の中から、ふにゃふにゃの袋が出てきて ちょっとブルーになったりした。

焼きそば作りの小技を教えるスレはここですか？

まて待ておまえら。
カップ焼きそばって焼いてないぞ？

�@蓋を半分ほど剥がしてかやくとソースを取り出す。
�A麺を取り出し、容器の底にかやくを開けてから麺を元に戻す。
�Bお湯を注ぐ。
�Cコンロにかけて強火で3分半。
�Dお湯を捨てる。
�E新しいお湯を注ぎ（面倒なら古いお湯そのままでも可）、ソースを入れる。
�Fお好みでマヨネーズ、スパイス等をかける。
�G(ﾟдﾟ)ｳﾏｰ

小技？（めんどくさい？）

union dbl{
　　double dbl;
　　struct{
　　　　int　　hoge1　:32;
　　　　int　　hoge2　:31;
　　　　int　　pm　　　:1;
　　}B8;
} dbl;

#define abs4dbl(x) ((dbl.dbl=(x)),(dbl.B8.pm=(0&(dbl.B8.pm)),dbl.dbl))

うちの環境では fabs の15倍は早い、どうっすか？

>>408
いいね。FPUレジスタ使わないし

（＾＾）

　　 ∧＿∧
　　（　　＾＾ ）＜ ぬるぽ（＾＾）

>>408
ｺﾚってｴﾝﾃﾞｨｱﾝやｱﾗｲﾒﾝﾄは考慮せんで良いの?
教えてｴﾛｲ人。

>>412
> ｺﾚってｴﾝﾃﾞｨｱﾝやｱﾗｲﾒﾝﾄは考慮せんで良いの?

それ以前に考慮すべき所があるだろ。

移植性皆無の小技だな。

━―━―━―━―━―━―━―━―━[JR山崎駅（＾＾）]━―━―━―━―━―━―━―━―━―

　　　 　∧＿∧
ﾋﾟｭ.ｰ　(　　＾＾ ） ＜これからも僕を応援して下さいね（＾＾）。
　　＝〔~∪￣￣〕
　　＝ ◎――◎ 　　　　　　　　　　　　　　　　　　　　　山崎渉

↑mailto:xxxli

「アルゴリズム体操」
こっち向いて二人で前へならえ
あっち向いて二人で前へならえ ♪
手を横に〜あら危ない〜
　 頭を下げればぶつかりません♪
手を横に〜あら危ない〜
　 頭を下げれば大丈夫♪
ぐるぐるぐる、ぐるぐるぐる、ぐ〜るぐる♪
ぐるぐるぐる、ぐるぐるぐる、ぐ〜るぐる♪
ぱっちんぱっちんがしんがしん、
ぱっちんぱっちんがしんがしん♪
吸って〜吐くのが深呼吸〜、 吸って〜吐くのが深呼吸〜♪

なぜかここでチラホラ出てくる年賀状ネタ、残念でした。
あなた方は完全にマークされています。

http://www.post.yusei.go.jp/zipcode/zipmanual/p10.htm
http://www.exp.org/zipcode/zipcode.html

　__∧＿∧_
　|（　　＾＾ ）|　＜寝るぽ（＾＾）
　|＼⌒⌒⌒＼
　＼ |⌒⌒⌒~|　　　　　　　　　山崎渉
　　 ~￣￣￣￣

>>389

MAXとかMIN使えばいいじゃん。
条件式ばっかりずらずら繋げて可読性の悪いコード書く香具師嫌い。

ワラタ

キーボードをきれいに掃除する小技教えて
一個一個はずすなんてめんどくさい

・エアスプレーを使う。
・カバーを付ける。
・汚れてもいいキーボードで作業する。
・無菌状態で作業する。

キーボードを買い替える。

そのまま洗濯機に放り込む。（洗剤不可）
良く乾かしてから使用する事。

洗剤使わなかったら、油とか取れねーじゃん。
ただ水浸しになるだけじゃん。
馬鹿？

>>427
オマイは油で汚れるような環境で使ってるのか…?
キーボードの汚れって、フツーは表面に手垢が付くか、
隙間にホコリが詰まる程度だと思うんだが。

でもサンポールはOKらしいぞ。>>426

とりあえずひっくりかえして古い歯ブラシでホコリをほじり出す。
浸らない程度に洗剤をつけてもいーかも

（＾＾）

　　　 (⌒V⌒)
　　　│ ＾ ＾ │＜これからも僕を応援して下さいね（＾＾）。
　　⊂|　　　　|つ
　　　（＿）（＿）　　　　　　　　　　　　　　　　　　　　　　山崎パン