알까기.pdf|
과거 모 방송사 코미디 프로그램에서 유행했던 추억의 알까기가 부활돼 인기다. 어린 시절 누구나 한번은 해봤던 단순하고 재미있는 놀이. 요즘은 노인들의 치매 예방에 큰 도움이 된다고 하여 노인정에서도 유행하고 있다. 알까기는 장난스러운 게임이지만 그 속을 들여다보면 물체의 충돌 현상을 이용하는 것으로 물리의 영역에 속한다. 서울대 물리학과 유인석 교수가 최근 ‘물리학과 첨단기술’(한국물리학회 발간)에 알까기에 담겨 있는 물리 법칙과 알까기 비법을 소개했다. 유교수는 알이 정면으로 부딪치는 ‘정면 알까기’와 옆에서 부딪치는 ‘빗겨 알까기’의 2가지로 나눠 실험을 실시했다. 실험에서는 바둑알 대신 동전을, 손 대신 볼펜 스프링을 이용해 퉁겼다. 그림과 같이 두 동전을 일정한 거리만큼 떨어뜨린 후 모눈종이 위에 놓고 한 동전을 퉁겨 정면으로 충돌하게 한다. 알까기에서 승부의 요체는 자신의 알은 그대로 유지한 채 상대방의 알을 얼마나 잘 맞춰 멀리 내보내느냐는 것이다. 그러므로 자신의 알이 움직인 거리(x2)에 대한 남의 알이 움직인 거리(x1)가 클수록 좋다. 알까기는 초기 속도가 가장 빠르고 점점 속도가 줄어드는 가속도운동이다. 또 퉁긴 알이 자신의 운동에너지를 퉁겨진 알에 전달하는 에너지 전달이 일어난다. 운동량 보존의 법칙에 의하면 충돌 직후 퉁긴 알은 바로 멈추고 충돌된 알이 같은 속도로 움직여야 하지만 실제로는 그렇지 않다. 이는 충돌할 때 소리 등으로 알의 운동에너지가 소모되기 때문이다. 실험에서 충돌 전후의 운동에너지 비율을 계산한 결과 두 알의 비율은 0.78이었다. 이는 충돌하는 알의 운동에너지 중 22%가 소리 등 다른 에너지로 전환된다는 의미다. 그러므로 물리법칙에 따르면 정면으로 알을 깔 때 상대방의 알보다 22%정도 가벼운 알을 택하면 유리하다. 바둑알일 경우 최대한 가벼운 알을 고르고 장기알은 가벼운 알로 약간 무거운 알을 공격하는 게 효과적인 셈이다. 다음으로 알을 비스듬히 빗겨서 퉁기는 경우를 생각해보자. 빗겨 알까기에서는 충돌한 후 알이 직진하지 않고 운동방향이 틀어진다. 두 알이 중심에서 빗긴 거리를 ‘충돌맺음변수’라고 하며 운동방향이 틀어지는 정도를 ‘쏠림각’이라고 한다. 이상적인 경우 쏠림각은 90도가 되어야 하지만 실제 충돌실험을 하면 대략 74도쯤 벌어진다. 이 역시 충돌시 ‘딱’하는 충돌음 등으로 에너지가 손실되기 때문이다. 벌어지는 각도가 일정한 이유는 운동량 보존법칙을 사용하는 2차원 충돌이론으로 설명된다. 알이 퉁겨지는 각도가 커지게 하려면 충격맺음변수를 크게, 즉 상대 알의 가장자리를 겨냥하면 된다. 유교수는 “실제 알까기에서는 알이 볼록하고 판과의 마찰력도 있으며 손에 힘이 실리는 정도에 따라 달라지기 때문에 이론치와는 차이가 난다”며 “물리공식들을 이해하면 알이 움직이는 정도를 예측할 수 있을 것”이라고 말했다. 알까기 실험은 2001년 서울대에서 주최한 수학·과학 경시대회에 출제된 바 있다. 기고 내용은 한국물리학회 홈페이지(www.kps.or.kr)에서 자세히 볼 수 있다. |
'Study'에 해당되는 글 250건
- 2007/08/23 알까기와 물리학
- 2007/08/16 boost 설치
- 2007/08/13 8.11(토) C# - 기초문법4
- 2007/08/13 8.11(토) C# - 기초문법3
- 2007/08/13 8.11(토) C# - 기초문법2
- 2007/08/13 8.11(토) C# - 기초문법1
- 2007/08/13 8.10(금) C++ 디자인패턴 - 정의
- 2007/08/13 8.10(금) C++ 디자인패턴 - Composite 을 활용한 메뉴생성5(최종)
- 2007/08/13 8.10(금) QT - 설치와 사용법
- 2007/08/13 8.9(목) C++ - Proxy의 활용
Tag | boost
using System;
// 1.언제 수집되는가 ? Context스위칭시간 10ms정도를 가비지시스템이 작동한다.
// 메모리를 일단 다 쓰게 한후에 어느정도 다 찼을 때 메모리를 비워준다.
// ( 메모리의 이동을 줄인다. )
// 2.세대 개념 0, 1, 2세대(관리 힙)로 차례대로 진행된다.
// 3.소멸자 호출
// C#과 Java는 소멸자를 만들지 않는다.
// 대신 IDisposable 인터페이스를 구현해라.
// WINDOW API를 가져다 쓸 때 HANDLE 같은것을 해제 시켜 줄 때만 소멸자의 역할을 만든다.
class Point
{
public int x;
public Point()
{
Console.WriteLine("Point.Point()");
}
public void Dispose()
{
Console.WriteLine("여기서 소멸자의 역할을 하게 해라.");
}
// c#도 소멸자를 만들 수 있다.( finalize라고 부른다. )
// 하지만 정확히 언제 호출 될지를 알 수 없다.
//~Point()
//{
// Console.WriteLine("Point.~Point()");
//}
}
class Test
{
public static void Main()
{
{
Point p1 = new Point();
p1.Dispose(); // 소멸 작업이 필요한 경우..호출
}
//GC.Collect(0); // 강제로 가비지 Collection을 한다.
//GC.Collect(0);
//Console.WriteLine("{0}", GC.CollectionCount(0));
Console.WriteLine("AAA");
}
}
Tag | c#
using System;
using System.Reflection; // c#의 reflect 서비스
// Reflection 메타데이타 에서 정보를 얻어온다.
class Point
{
public int x;
public int y;
public void foo() { }
}
class Test
{
public static void Main()
{
Point p = new Point();
Type t = p.GetType(); // p의 type 정보를 담고 있는 객체를 얻는다.
// RTTI, RTCI(MFC)
Console.WriteLine("{0}", t.FullName);
Console.WriteLine("{0}", t.BaseType.FullName);
// t의 모든 메소드 정보를 배열로 얻어 온다.
MethodInfo[] mis = t.GetMethods();
// 배열의 모든 요소를 열거하면서 출력한다.
foreach (MethodInfo m in mis)
{
Console.WriteLine("{0}, {1}", m.Name, m.ReturnType);
}
}
}
// Monostate : static 멤버 data와 static 멤버 변수만 가진 클래스 객체를
만들 필요가 없다.
class Math
{
//private Math() { }
public static int plus(int a, int b) { return a + b; }
}
Math.plus(1, 2);
///////////////////////////////////////////////////////////////////////////
// 델리게이트 선언
delegate void CrashHandler( int a );
// 위 선언을 보고 C#컴파일러가 CrashHandler라는 클래스를 생성해 준다.
// 내부적으로 void를 리턴하고 int 인자가 1개인 함수 포인터를 관리해주는 클래스.
class Car
{
public int speed = 0;
public CrashHandler handler; // 델리게이터의 참조
public void SetSpeed(int n)
{
speed = n;
if (handler != null)
handler.Invoke(n); //handler(n); // 외부에 알린다.
}
}
class Test
{
public static void foo(int a)
{
Console.WriteLine("Test::foo - {0}", a);
}
public static void Main()
{
Car c = new Car();
c.handler = new CrashHandler(Test.foo);
c.handler += new CrashHandler(Test.foo);
}
}
Tag | c#
using System;
// C++ 과 다른 C#의 핵심 문법들
// 1. Property : 구현자 입장에서는 함수(제어문 가능)
// 사용자 입장에서는 Data처럼 보인다.
// 2. indexer : C++의 배열 연산자 재정의..
class Bike
{
private int gear;
private int[] array = new int[10]; // C#의 배열 만드는 법.
public int Gear
{
get { return gear; }
set { if( value < 100 ) gear = value; }
}
public int this[int name] // set_Item( name, value ) 함수로 제공된다.
{
get { return array[name]; }
set { array[name] = value; }
}
}
class Test
{
public static void Main()
{
Bike p = new Bike();
p.Gear = 10;
Console.WriteLine("{0}", p.Gear);
}
}
//////////////////////////////////////////////////////
// out 파라미터와 Ref 파라미터
// 결국 항상 C처럼 메모리 그림을 그려서 해결하면 됩니다.
class Point
{
public int x;
}
class Test
{
public static void foo(out Point p)
{
//p.x = 20;
p = new Point();
p.x = 100;
}
public static void Main()
{
Point p1 = new Point();
p1.x = 10;
foo(out p1);
Console.WriteLine("{0}", p1.x);
}
}
class Test
{
public static void foo(out int a)
{
a = 20;
}
public static void Main()
{
int x = 10;
foo(out x);
Console.WriteLine("{0}", x);
}
}
//////////////////////////////////////////////////////////
// 결국 C++ : type 사용자가 메모리의 위치 결정
// C# : type 제작자가 메모리의 위치 결정
// 무조건 참조 type이다.
class Point1
{
public int x;
public int y;
}
// 구조체는 무조건 값 type이다. stack에 객체가 만들어 진다.
struct Point2
{
public int x;
public int y;
}
class Test
{
public static void Main()
{
Point1 p1; // 참조 일 뿐이다.
Point2 p2; // 객체이다.
Point1 p3 = new Point1(); // 힙에 만든다.
Point2 p4 = new Point2(); // stack에 만든다.
// int는 구조체이다.
int a;
Point1 pp; // 실제 Point1이 아니고 C++의 포인터개념이다.
// (C#에서는 레퍼런스라고 한다.)
//Point1 p = new Point1; // C++
Point1 p = new Point1(); // C#
int a = 0;
int b = new int();
}
}
Tag | c#
using System; // using namespace System의 의미
// 1. Main 함수의 기본 모양
// 2. Console 클래스의 static 함수들을 사용해서 표준 입출력을 처리한다.
// 3. %d 대신 {0}, {1} 을 사용.
// 4. 모든 것은 객체이다. 결국 Object의 자식이다.
class Test
{
public void foo()
{
}
public static void Main()
{
int a = 10;
int b = 20;
Console.WriteLine("a= {0} {1} {0}", a, b);
}
}
///////////////////////////////////////////////////////////////
// 주제 2. 모든 것은 객체이다. 그리고 모든 것은 Object의 자식이다.
class Point
{
public int x = 0; // 필드 초기화 가능
public int y = 0; // 필드 초기화 가능
public Point( int a, int b )
{
x = a;
y = b;
}
// 부모인 Object의 ToString() 멤버 함수를 재정의 한다.
// C#은 가상함수 재정의시 override 키워드를 사용한다.
public override string ToString()
{
return "[Point]";
}
}
class Test
{
public static void Main()
{
int a = 10; // int는 별명에 불과하다.
System.Int32 b = 0;
Console.WriteLine("{0}", a);
Point p = new Point(1, 1); // 주의 C++은 new Point;
Console.WriteLine("{0}", p.ToString());
}
}
Tag | c#
1. 오직 한 개만 만들수 있는 객체 -> 싱글톤
2. 자신의 사본을 만드는 가상함수 -> Prototype
3. data의 변화를 여려명에 알려주자 -> Observer, MFC( Doc/View )
4. 기존 클래스의 인터페이스만 변경해서 다른 클래스처럼 보이게 한다.->Adapter, STL stack
5. 그릇은 그릇과 객체를 모두 담을 수 있다. -> Composite ****
6. 객체에 포장을 한다. 포장 후 다시 포장이 가능하다.
기본 기능을 하는 객체와 그 기능을 쉽게 사용 할 수 있게 하는 객체가 있다. -> Decorator
7. 객체를 만드는 공장을 짓자. ? Factory
8. Collection의 모든 요소를 열거하는 객체 -> 반복자
9. Collection 내부를 떠돌아 다니는 객체 -> Visitor ( 하나씩을 돌아다니며 변경 )
10. 기존 객체를 데신하는 역할의 객체를 만들자 -> Proxy
11. 작고 여러 개 만들어지는 객체는 공유해서 사용하자. -> fly weight
12. 프로그램의 전체 틀을 미리 설계해 놓자. ? Application Framework( 창시자 책 )
13. 책임을 다른 곳에 전달해서 하나의 문제를 여러객체가 처리 할수 있도록 하자.
책임전가 ? Chain of Responsibility
14. 알고리즘 자체를 캡슐화 하면 변경이 쉬워 진다. ? 전략 패턴
15. 부모에 비가상함수로 알고리즘을 자식에 protected 가상함수로 알고리즘의 구현을 제공하자.
template method( 메뉴, 아이스크림 )
16. 객체에 사건이 발생시 외부에 전달하는 기법 ? callback, event, signal
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <conio.h>
using namespace std;
using namespace std::tr1;
#define interface struct
#define clrscr() system("cls")
//***************************************
// IMenuHandler
//***************************************
interface IMenuHandler
{
virtual ~IMenuHandler() {}
virtual void OnCommand( unsigned int id ) = 0;
};
//***************************************
// AbstractMenu
//***************************************
class AbstractMenu
{
string title;
public:
AbstractMenu( string s) : title(s) {}
virtual ~AbstractMenu() {}
virtual string GetTitle() const { return title;}
virtual void Command() = 0;
};
//***************************************
// MenuItem
//***************************************
class MenuItem : public AbstractMenu
{
unsigned int id;
IMenuHandler* pMenuHandler;
public:
MenuItem( string s, unsigned int i, IMenuHandler* pHandler)
: AbstractMenu(s), id(i), pMenuHandler(pHandler) {}
virtual void Command() { pMenuHandler->OnCommand( id ); }
};
//***************************************
// PopupMenu
//***************************************
class PopupMenu : public AbstractMenu
{
typedef shared_ptr<AbstractMenu> PAbstractMenu;
vector<PAbstractMenu> menu_list;
bool isroot;
typedef list<Tape*> TapeList; // 테입 리스트를 명확하게 표현 해준다.
public:
static string str_exit;
static string str_goback;
int xpos, ypos; // 현재 팝업 메뉴가 나타 날 위치로 메뉴를 뜨게 해준다.!!
public:
PopupMenu(string s, bool b = false) : AbstractMenu( s ), isroot(b) {}
void Append(AbstractMenu* m) { menu_list.push_back( (PAbstractMenu)m);}
virtual void Command()
{
while( 1 )
{
clrscr();
size_t cnt = menu_list.size();
for ( size_t i = 0; i < cnt; ++i )
cout << i + 1 << ". " <<
menu_list[i]->GetTitle() << endl;
cout << cnt + 1 << ". " <<
( isroot ? str_exit:str_goback) << endl;
unsigned int cmd;
cout << "메뉴를선택하세요>> ";
cin >> cmd;
// 문자를 입력 한 경우
if ( cin.fail() )
{
cin.clear();
cin.ignore(256, '\n');
continue;
}
if ( cmd < 1 || cmd > cnt + 1 ) continue;
if ( cmd == cnt + 1 ) return ;
menu_list[cmd-1]->Command();
}
}
};
string PopupMenu::str_exit = "종료";
string PopupMenu::str_goback = "이전메뉴로";
//---------------------------------------------
// Menu Class 활용 예제..
class VideoShop : public IMenuHandler
{
shared_ptr<PopupMenu> pMenuBar; // video shop의 메인 메뉴
public:
VideoShop() : pMenuBar( new PopupMenu("ROOT", true))
{ }
virtual void OnCommand( unsigned int id )
{
cout << id << " 메뉴가선택됨" << endl;
getch();
}
void InitMenu()
{
// initialize menu
PopupMenu* p1 = new PopupMenu( "고객관리" );
p1->Append( new MenuItem( "고객등록", 1, this ));
p1->Append( new MenuItem( "고객삭제", 2, this ));
p1->Append( new MenuItem( "기타", 3, this ));
PopupMenu* p2 = new PopupMenu( "Tape 관리" );
p2->Append( new MenuItem( "Tape 등록", 11, this ));
p2->Append( new MenuItem( "Tape 삭제", 12, this ));
p2->Append( new MenuItem( "기타", 13, this ));
PopupMenu* p3 = new PopupMenu( "대여관리" );
p3->Append( new MenuItem( "대여등록", 21, this ));
p3->Append( new MenuItem( "반납", 22, this ));
p3->Append( new MenuItem( "기타", 23, this ));
pMenuBar->Append( p1 );
pMenuBar->Append( p2 );
pMenuBar->Append( p3 );
PopupMenu::str_exit = "Exit";
PopupMenu::str_goback = "Go Back";
}
void Start()
{
InitMenu();
pMenuBar->Command();
}
};
int main()
{
VideoShop vs;
vs.Start();
}
Tag | QT
#include <iostream>
using namespace std;
// C# : .Net Remoting
// JAVA : RMI
// COM : 분산COM
// 원격제어에 있는 메소드를 호출하겠다.
// proxy ( foo(1, 2) ) -> 마샬리-> 스텁-> 서버측 foo호출
// proxy를 제대로 써보자.
class Printer
{
public:
Printer()
{
cout << "Warming up" << endl;
for ( int i = 0; i < 1000000000; ++i );
cout << "OK..." << endl;
}
void print() const
{
cout << "Printer::print" << endl;
}
void print_time() const
{
cout << "print_time()" << endl;
}
};
// printer를 대신 할 proxy를 만든다.
// 대행자를 만들어서 사용하도록 하자.
class PrinterProxy
{
Printer* p;
public:
void print_time() const
{
cout << "print_time()" << endl;
}
void print() const
{
// 진짜 객체가 필요하면 만들어서 사용한다.
if ( p == 0 )
p = new Printer;
p->print();
}
};
void main()
{
Printer p;
p.print_time();
}
Tag | C++
