index.xml

<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>tantk land</title>
    <link>https://o-tantk.github.io/</link>
    <description>Recent content on tantk land</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>euc-kr</language>
    <managingEditor>tantk90@hotmail.com (tantk)</managingEditor>
    <webMaster>tantk90@hotmail.com (tantk)</webMaster>
    <lastBuildDate>Tue, 15 Nov 2016 22:45:08 +0900</lastBuildDate>
    <atom:link href="https://o-tantk.github.io/index.xml" rel="self" type="application/rss+xml" />
    
    <item>
      <title>회전 행렬(Rotation matrix)의 유도</title>
      <link>https://o-tantk.github.io/posts/derive-rotation-matrix/</link>
      <pubDate>Tue, 15 Nov 2016 22:45:08 +0900</pubDate>
      <author>tantk90@hotmail.com (tantk)</author>
      <guid>https://o-tantk.github.io/posts/derive-rotation-matrix/</guid>
      <description>

&lt;script type=&#34;text/javascript&#34;
  src=&#34;https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML&#34;&gt;
&lt;/script&gt;

&lt;h1 id=&#34;사설:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;사설&lt;/h1&gt;

&lt;p&gt;회전 행렬(Rotation matrix)은 보통 한 번 구현해 놓고, 사용만 하기 때문에 좀처럼 외워지지 않았다. 특히 &lt;code&gt;cos&lt;/code&gt;, &lt;code&gt;sin&lt;/code&gt;의 위치는 기억해도 &lt;code&gt;-&lt;/code&gt;가 어느 &lt;code&gt;sin&lt;/code&gt;에 붙는지 자꾸 헷갈렸다.&lt;/p&gt;

&lt;p&gt;그래서, 행렬식 자체를 외우기 보다 유도하는 방법을 외우기로 했다.&lt;/p&gt;

&lt;p&gt;회전 행렬을 유도하는 방법에는 여러가지가 있다. 삼각형의 합동을 이용한 방법(고등수학), 벡터의 내적을 이용한 방법 등&amp;hellip;. 이 방법들을 사용해도 전혀 어려울 것은 없지만, 팟 하고 떠올리기엔 조금 무리가 있다.&lt;/p&gt;

&lt;p&gt;좀 더 쉬운 유도 방법을 찾아보니, 다행히 &lt;strong&gt;가장 쉽다&lt;/strong&gt;고 할 수 있을 유도 방법이 존재했다. 바로 회전 행렬이 선형 변환(선형 사상)임을 이용해 유도하는 것이다.&lt;/p&gt;

&lt;h2 id=&#34;선형-변환-linear-transformation:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;선형 변환(Linear transformation)&lt;/h2&gt;

&lt;p&gt;두 벡터 공간 사이의 변환 \( f \)와 임의의 상수 \( c \), 두 벡터 \( \alpha \), \( \beta \)가 다음을 만족하는 경우, \( f \)를 선형 변환이라 한다.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;\( f\left( \alpha +\beta \right) =f\left( \alpha \right) +f\left( \beta \right) \)&lt;/li&gt;
&lt;li&gt;\( f\left( c\alpha \right) =cf\left( \alpha \right) \)&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;선형 변환을 만족하는 대표적인 변환이 바로 회전이며, 확대(Scaling), 찌그러트림(Shear), 대칭(Reflection), 사영(Projection) 등도 여기에 해당한다.&lt;/p&gt;

&lt;p&gt;\( \theta \)만큼 회전하고 \( \omega \)만큼 회전하든, \( \omega \)만큼 회전하고 \( \theta \)만큼 회전하든, 그 결과는 \( (\theta + \omega) \)임을 생각해보면, 회전이 선형 변환임을 금새 알 수 있다.&lt;/p&gt;

&lt;p&gt;참고로 이동(Translation)은 선형 변환이 아니다. 때문에 하나의 행렬로 변환을 표현하기 위해, 동차좌표계(Homogeneous coordinates)를 이용한 아핀 변환(Affine transformation)이 사용되는 것이다.&lt;/p&gt;

&lt;h1 id=&#34;유도:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;유도&lt;/h1&gt;

&lt;p&gt;먼저 기저 벡터인 \( ( 1, 0 ) \)과 \( ( 0, 1 ) \)를 \( \theta \)만큼 회전시켜 보자.
&lt;img src=&#34;graph.png&#34; alt=&#34;기저 벡터의 회전&#34; /&gt;
그림과 같이 \( ( 1, 0 ) \)을 \( \theta \)만큼 회전하면 \( ( \cos { \theta }, \sin { \theta } ) \), \( ( 0, 1 ) \)을 \( \theta \)만큼 회전하면 \( ( -\sin { \theta }, \cos { \theta } ) \)이 된다.&lt;/p&gt;

&lt;p&gt;그리고, 회전 행렬 \( R \)은 선형 변환이므로 다음이 성립된다.&lt;/p&gt;

&lt;div&gt;$$
\begin{align*} R\begin{bmatrix} x \\ y \end{bmatrix} &amp;=R\begin{bmatrix} x \\ 0 \end{bmatrix}+R\begin{bmatrix} 0 \\ y \end{bmatrix}\\ &amp;=R\begin{bmatrix} 1 \\ 0 \end{bmatrix}x+R\begin{bmatrix} 0 \\ 1 \end{bmatrix}y \end{align*}
$$&lt;/div&gt;

&lt;p&gt;여기서 \( R (1, 0) \)과 \( R (0, 1) \)이 바로 \( ( \cos { \theta }, \sin { \theta } ) \), \( ( -\sin { \theta }, \cos { \theta } ) \)이므로, 대입하면 유도가 끝난다.&lt;/p&gt;

&lt;div&gt;$$
\begin{align*} R\begin{bmatrix} x \\ y \end{bmatrix} &amp;=\begin{bmatrix} \cos { \theta }  \\ \sin { \theta } \end{bmatrix}x+\begin{bmatrix} -\sin { \theta } \\ \cos { \theta } \end{bmatrix}y\\ &amp;=\begin{bmatrix} \cos { \theta } &amp; -\sin { \theta } \\ \sin { \theta } &amp; \cos { \theta } \end{bmatrix}\begin{bmatrix} x \\ y \end{bmatrix} \\ \\ R &amp;=\begin{bmatrix} \cos { \theta } &amp; -\sin { \theta } \\ \sin { \theta } &amp; \cos { \theta } \end{bmatrix} \end{align*}
$$&lt;/div&gt;

&lt;p&gt;정말 쉽다.&lt;/p&gt;

&lt;p&gt;3차원의 경우는 회전축에 대해 \( R \overrightarrow { v } = \overrightarrow { v } \)이므로 더 생각할 것도 없다.&lt;/p&gt;

&lt;div&gt;$$
\begin{align*} { R }_{ z }\begin{bmatrix} x \\ y \\ z \end{bmatrix} &amp;={ R }_{ z }\begin{bmatrix} x \\ 0 \\ 0 \end{bmatrix}+{ R }_{ z }\begin{bmatrix} 0 \\ y \\ 0 \end{bmatrix}+{ R }_{ z }\begin{bmatrix} 0 \\ 0 \\ z \end{bmatrix}\\ &amp;={ R }_{ z }\begin{bmatrix} 1 \\ 0 \\ 0 \end{bmatrix}x+{ R }_{ z }\begin{bmatrix} 0 \\ 1 \\ 0 \end{bmatrix}y+{ R }_{ z }\begin{bmatrix} 0 \\ 0 \\ 1 \end{bmatrix}z\\ &amp;=\begin{bmatrix} \cos { \theta  } \\ \sin { \theta } \\ 0 \end{bmatrix}x+\begin{bmatrix} -\sin { \theta } \\ \cos { \theta } \\ 0 \end{bmatrix}y+\begin{bmatrix} 0 \\ 0 \\ 1 \end{bmatrix}z\\ &amp;=\begin{bmatrix} \cos { \theta }  &amp; -\sin { \theta } &amp; 0 \\ \sin { \theta } &amp; \cos { \theta } &amp; 0 \\ 0 &amp; 0 &amp; 1 \end{bmatrix}\begin{bmatrix} x \\ y \\ z \end{bmatrix} \\ \\ { R }_{ z } &amp;=\begin{bmatrix} \cos { \theta } &amp; -\sin { \theta } &amp; 0 \\ \sin { \theta } &amp; \cos { \theta } &amp; 0 \\ 0 &amp; 0 &amp; 1 \end{bmatrix} \end{align*}
$$&lt;/div&gt;

&lt;p&gt;같은 방법으로 \( { R }_{ x } \), \( { R }_{ y } \)도 쉽게 구할 수 있다.&lt;/p&gt;

&lt;h1 id=&#34;references:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;References&lt;/h1&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://ko.wikipedia.org/wiki/선형변환&#34;&gt;https://ko.wikipedia.org/wiki/선형변환&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</description>
    </item>
    
    <item>
      <title>중앙값(Median) 찾기</title>
      <link>https://o-tantk.github.io/posts/finding-median/</link>
      <pubDate>Sat, 12 Nov 2016 01:47:05 +0900</pubDate>
      <author>tantk90@hotmail.com (tantk)</author>
      <guid>https://o-tantk.github.io/posts/finding-median/</guid>
      <description>

&lt;h1 id=&#34;중앙값-median:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;중앙값(Median)&lt;/h1&gt;

&lt;p&gt;중앙값이란, 어떤 배열을 정렬했을 때 정 가운데에 위치하는 값을 말한다. (수학적으로는 확률분포가 0.5인 값이다.)&lt;br /&gt;
예를들어, &lt;code&gt;[1, 2, 3]&lt;/code&gt;의 배열에서는 &lt;code&gt;2&lt;/code&gt;가 중앙값이다.&lt;/p&gt;

&lt;p&gt;원소의 개수가 짝수인 경우엔, 가운데 두 원소의 평균이 중앙값이 된다.&lt;br /&gt;
&lt;code&gt;[1, 2, 3, 4]&lt;/code&gt;에서는 &lt;code&gt;2&lt;/code&gt;와 &lt;code&gt;3&lt;/code&gt;의 평균인 &lt;code&gt;2.5&lt;/code&gt;가 중앙값인 것이다.&lt;/p&gt;

&lt;h2 id=&#34;중앙값-찾기:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;중앙값 찾기&lt;/h2&gt;

&lt;p&gt;중앙값은 &lt;strong&gt;정렬된 배열&lt;/strong&gt;에서 찾아야 한다.&lt;br /&gt;
배열이 정렬되어 있다면 땡큐지만, 정렬되어 있지 않다면 정렬해야 하므로, 가장 먼저 정렬을 수행해야 한다.&lt;/p&gt;

&lt;p&gt;정렬 후엔, 단순히 배열 크기의 절반에 해당하는 인덱스에 접근해 반환하면 된다.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-c++&#34;&gt;float median(vector&amp;lt;int&amp;gt; &amp;amp;arr){
    sort(arr.begin(), arr.end());

    if(arr.size() % 2 == 1){
        return (float)arr[arr.size() / 2];
    }
    else{
        return ((float)arr[arr.size() / 2] + (float)arr[arr.size() / 2 + 1]) / 2.0f; 
    }
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;&lt;code&gt;int&lt;/code&gt;형 자료를 갖는 배열임에도 &lt;code&gt;float&lt;/code&gt;형을 반환하는 이유는, 짝수개에 대한 중앙값의 정의 때문이다. 물론 소수점 이하가 필요 없다면 그대로 반환해도 되겠다. 반올림이 아닌 절삭인 것도 감안하고.&lt;/p&gt;

&lt;h2 id=&#34;실시간으로-중앙값-running-median-찾기:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;실시간으로 중앙값(Running Median) 찾기&lt;/h2&gt;

&lt;p&gt;중앙값을 찾기 위해선 배열의 정렬이 선행되어야 한다. 그렇다면, 데이터가 지속적으로 추가/삭제되고 있는 상황에서 중앙값을 찾으려면 어떻게 해야 할까? 위의 방법을 이용한다면, 중앙값을 찾을 때마다 배열 전체에 대한 정렬을 시도하므로 엄청난 시간 낭비가 아닐 수 없다.&lt;/p&gt;

&lt;p&gt;그래서 값을 찾을 때마다 정렬하기 보다는, 자료구조 자체를 바꿔야 하겠다. 수행 속도가 훨씬 빠른, 추가/삭제가 정렬과 함께 이루어지는 자료 구조를 이용하는 것이다. 추가/삭제가 정렬과 함께 이루어지는 자료 구조는 여러가지가 있지만, 중앙값을 찾는 데는 &lt;a href=&#34;https://ko.wikipedia.org/wiki/힙_(자료_구조)&#34;&gt;Heap&lt;/a&gt;을 이용할 수 있다.&lt;/p&gt;

&lt;h3 id=&#34;알고리즘:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;알고리즘&lt;/h3&gt;

&lt;blockquote&gt;
&lt;ul&gt;
&lt;li&gt;Max heap은 최대값에 바로 접근할 수 있다.&lt;/li&gt;
&lt;li&gt;Min heap은 최소값에 바로 접근할 수 있다.&lt;/li&gt;
&lt;/ul&gt;
&lt;/blockquote&gt;

&lt;p&gt;Heap의 두 성질 이용해, 중앙값보다 작은 값들은 Max heap에, 중앙값보다 큰 값들은 Min heap에 저장하는 방식으로 중앙값을 찾는 알고리즘을 구현할 수 있다. 아래의 상황을 보자.
&lt;img src=&#34;diagram00.png&#34; alt=&#34;첫 번째 단계&#34; /&gt;
먼저, 작은 값과 큰 값을 나눌 기준이 필요하다. 중앙값이 아니라 굳이 기준이라 표현한 이유는, 개수가 짝수일 때를 고려해서이다.&lt;br /&gt;
기준은 어차피 가운데에 있으니, 변수를 따로 만들 필요 없이 Max heap 또는 Min heap에 포함시키면 된다. 여기선 Max heap을 이용했다.
&lt;img src=&#34;diagram01.png&#34; alt=&#34;두 번째 단계&#34; /&gt;
첫 번째 입력은 별 수 없이 기준이 된다. 홀수개이므로 중앙값은 &lt;code&gt;3&lt;/code&gt;이다.&lt;br /&gt;
나머지는 기준보다 작다면 Max heap에, 크다면 Min heap에 넣는다. 그리고, Max heap과 Min heap의 크기가 균형되도록 조절한다. 다만, 기준을 고려해 기준을 가진쪽이 하나는 더 클 수 있도록 허용한다.
&lt;img src=&#34;diagram02.png&#34; alt=&#34;세 번째 단계&#34; /&gt;
&lt;img src=&#34;diagram03.png&#34; alt=&#34;네 번째 단계&#34; /&gt;
&lt;code&gt;2&lt;/code&gt;는 기준보다 작으니 Max heap에 넣지만 균형을 맞추기 위해 Max heap의 최대값을 이동시킨다. 짝수개이므로 중앙값은 &lt;code&gt;2&lt;/code&gt;와 &lt;code&gt;3&lt;/code&gt;의 평균이다.
&lt;img src=&#34;diagram04.png&#34; alt=&#34;다섯 번째 단계&#34; /&gt;
&lt;img src=&#34;diagram05.png&#34; alt=&#34;여섯 번째 단계&#34; /&gt;
&lt;code&gt;4&lt;/code&gt;는 기준보다 크니 Min heap에 넣지만 균형을 맞추기 위해 Min heap의 최소값을 이동시킨다. 홀수개이므로 중앙값은 &lt;code&gt;3&lt;/code&gt;이다.
&lt;img src=&#34;diagram06.png&#34; alt=&#34;일곱 번째 단계&#34; /&gt;
&lt;img src=&#34;diagram07.png&#34; alt=&#34;여덟 번째 단계&#34; /&gt;
&lt;code&gt;1&lt;/code&gt;은 기준보다 작으니 Max heap에 넣지만 균형을 맞추기 위해 Max heap의 최대값을 이동시킨다. 짝수개이므로 중앙값은 &lt;code&gt;2&lt;/code&gt;와 &lt;code&gt;3&lt;/code&gt;의 평균이다.&lt;/p&gt;

&lt;p&gt;입력이 들어올 때마다 한 번의 데이터 이동만으로 실시간으로 중앙값을 찾고 있다. Heap의 시간복잡도가 &lt;code&gt;O(log N)&lt;/code&gt;이므로 최악의 경우라도 &amp;lsquo;삽입 + 삭제 + 삽입&amp;rsquo;의 &lt;code&gt;O(3 log N)&lt;/code&gt;의 성능을 보인다.&lt;/p&gt;

&lt;h3 id=&#34;구현:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;구현&lt;/h3&gt;

&lt;p&gt;Heap을 직접 구현하는 귀찮은 짓을 할 수도 있겠지만, STL에서 이미 &lt;code&gt;priority_queue&lt;/code&gt;라는 이름으로 제공하고 있으므로 이용하면 된다.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-c++&#34;&gt;priority_queue&amp;lt;int&amp;gt; max_heap;
priority_queue&amp;lt;int, vector&amp;lt;int&amp;gt;, greater&amp;lt;int&amp;gt; &amp;gt; min_heap;
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;&lt;code&gt;priority_queue&lt;/code&gt;는 기본으로 선언하면 오름차순 정렬인 Max heap이 된다. &lt;code&gt;greater&amp;lt;int&amp;gt;&lt;/code&gt;를 템플릿 인자로 주면 내림차순 정렬인 Min heap을 선언할 수 있다.&lt;br /&gt;
두 번째 템플릿 인자는 &lt;code&gt;priority_queue&lt;/code&gt;의 컨테이너를 결정한다. 무난하게 &lt;code&gt;vector&lt;/code&gt;로 선언해주면 된다. &lt;code&gt;priority_queue&lt;/code&gt;에 대한 자세한 설명을 원한다면 &lt;a href=&#34;http://www.cplusplus.com/reference/queue/priority_queue/?kw=priority_queue&#34;&gt;레퍼런스&lt;/a&gt;를 참고하길 바란다.&lt;/p&gt;

&lt;p&gt;다음의 코드는 &lt;code&gt;int number&lt;/code&gt;에 &lt;code&gt;cin&lt;/code&gt;을 통해서 지속적으로 값을 읽어들이는 상황이라 가정한 것이다.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-c++&#34;&gt;priority_queue&amp;lt;int&amp;gt; smaller; // Max heap
priority_queue&amp;lt;int, vector&amp;lt;int&amp;gt;, greater&amp;lt;int&amp;gt; &amp;gt; bigger; // Min heap

int number;
cin &amp;gt;&amp;gt; number; // 첫 번째 입력.
smaller.push(number); // 기준이 smaller에 있다고 가정하므로, 첫 입력은 smaller에 넣는다.

while(true){
    cin &amp;gt;&amp;gt; number; // 두 번째 이후의 입력.
    if(number &amp;lt; smaller.top()){
        // 기준보다 작은 경우 smaller에 넣는다.
        smaller.push(number);
    }
    else{
        // 기준보다 큰 경우 bigger에 넣는다.
        bigger.push(number);
    }

    // smaller의 크기와 bigger의 크기가 같거나, smaller의 크기가 하나 더 크게 유지되도록 데이터를 옮긴다. 
    if(smaller.size() &amp;lt; bigger.size()){
        smaller.push(bigger.top());
        bigger.pop();
    }
    else if(smaller.size() &amp;gt; bigger.size() + 1){
        bigger.push(smaller.top());
        smaller.pop();
    }

    // smaller와 bigger의 크기가 같다면 총 개수는 짝수이다.
    if(smaller.size() == bigger.size()){
        cout &amp;lt;&amp;lt; ((float)smaller.top() + (float)bigger.top()) * 0.5f &amp;lt;&amp;lt; endl;
    }
    else{
        cout &amp;lt;&amp;lt; smaller.top() &amp;lt;&amp;lt; endl;
    }
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;세-수-triple-의-중앙값-찾기:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;세 수(Triple)의 중앙값 찾기&lt;/h2&gt;

&lt;p&gt;퀵정렬을 설계할 때 Pivot을 선택하는 방법에는 여러가지가 있지만, 대표적으로는 임의의 한 원소를 선택하는 방법과 &lt;strong&gt;처음, 중간, 끝의 원소 중 중앙값인 원소를 선택하는 방법&lt;/strong&gt;의 두 가지가 있다.&lt;/p&gt;

&lt;p&gt;퀵정렬에서 써먹을 수 있도록 세 수 중에서 중앙값을 찾는 방법을 생각해보자.&lt;br /&gt;
기본적인 방법은, 다량의 조건문을 이용해 찾는 것이다.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-c++&#34;&gt;int median(int a, int b, int c){
    if (a &amp;gt; b){
        if (b &amp;gt; c)          return b;
        else if (a &amp;gt; c)     return c;
        else                return a;
    }
    else{
        if (a &amp;gt; c)          return a;
        else if (b &amp;gt; c)     return c;
        else                return b;
    }
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;조건부 연산자(&lt;code&gt;exp?exp:exp&lt;/code&gt;)를 이용하면 코드가 좀 더 짧아지겠지만, 해석하기 어려워 진다.&lt;/p&gt;

&lt;p&gt;교환 법칙이 성립되는 XOR의 성질을 이용한다면, 분기 없이 중앙값을 찾을 수도 있다.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-c++&#34;&gt;int median(int a, int b, int c){
    int maximum = max(max(a, b), c);
    int minimum = min(min(a, b), c);
    return a ^ b ^ c ^ maximium ^ minimum;
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;세 수 모두를 XOR로 결합하고, 다시 최대값 최소값을 XOR로 제외함으로써 중앙값을 구했다.&lt;br /&gt;
XOR에 관한 내용은 &lt;a href=&#34;https://o-tantk.github.io/posts/reverse-array/&#34;&gt;이 포스트&lt;/a&gt;를 참조하길 바란다.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>랜덤 뽑기</title>
      <link>https://o-tantk.github.io/posts/randomized-array/</link>
      <pubDate>Thu, 20 Oct 2016 18:26:57 +0900</pubDate>
      <author>tantk90@hotmail.com (tantk)</author>
      <guid>https://o-tantk.github.io/posts/randomized-array/</guid>
      <description>

&lt;h1 id=&#34;임의의-접근:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;임의의 접근&lt;/h1&gt;

&lt;p&gt;&amp;lsquo;임의(랜덤)&amp;lsquo;라는 말을 들으면 &lt;code&gt;rand()&lt;/code&gt;를 이용해 무작위로 접근하는 방법이 가장 먼저 떠오를 것이다. 그러나 당연하게도 무작위 접근은 중복 접근을 방지하지 못 한다.&lt;br /&gt;
그렇다면, 중복을 피해서 배열에 임의로 접근하려면 어떻게 해야 할까.&lt;/p&gt;

&lt;h2 id=&#34;방문-여부를-기록하는-방법:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;방문 여부를 기록하는 방법&lt;/h2&gt;

&lt;p&gt;가장 손쉽게 생각해낼 수 있는 방법은, 임의 접근하는 배열의 각 원소마다 방문 여부를 기록하고, 중복된 접근이면 새로운 임의 접근을 시도하도록 구현하는 것이다.&lt;/p&gt;

&lt;p&gt;코드로 보면 다음과 같다.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-c++&#34;&gt;// arr는 std::vector를 이용한 임의의 배열.

std::vector&amp;lt;bool&amp;gt; visited(arr.size(), false);

int indexToVisit = rand() % arr.size(); // [0, size)
while(visited[indexToVisit]) {
    indexToVisit = rand() % arr.size();
}
visited[indexToVisit] = true;

arr[indexToVisit] ...
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;그러나, 이 방식에는 문제가 있는데, 위 코드에서 볼 수 있듯이 방문 기록이 없는 인덱스가 나올때까지 새로운 접근을 반복 시도한다는 점이다. 이는 방문한 원소의 수가 늘어갈수록, 배열의 크기가 클수록 더 큰 문제가 된다. 배열의 대부분을 방문하고 나면, 무한에 가까운 루프를 시도할지도 모른다.&lt;/p&gt;

&lt;h2 id=&#34;접근-영역을-한정하는-방법:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;접근 영역을 한정하는 방법&lt;/h2&gt;

&lt;p&gt;이 문제를, 여러개의 공이 들어있는 주머니에서 임의의 한 개를 뽑는 문제라고 생각해 보자. 공을 뽑을 때 전에 뽑았던 공을 다시 뽑지 않으려면, 뽑은 공을 주머니에 도로 넣지 않고 다른 곳에 보관해두면 된다.&lt;br /&gt;
그러나, 배열에서 이를 적용하기란 쉽지 않은 일이다. 원소를 마음대로 떼었다 붙였다 할 수 있는 것이 아니니까. 그렇다면 어떻게 해야 좋을까? 데이터 스왑을 이용하면 생각보다 간단히 해결할 수 있다.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;먼저, 배열 전체를 임의 접근할 수 있는 영역으로 설정해 놓는다.&lt;br /&gt;&lt;/li&gt;
&lt;li&gt;방문할 임의의 원소를 영역 내에서 선택하고, 해당 원소를 영역의 끝으로 옮겨놓는다. 동시에 영역의 크기를 한 칸 줄인다.&lt;br /&gt;&lt;/li&gt;
&lt;li&gt;옮겨놓은 원소를 사용한다.&lt;br /&gt;&lt;/li&gt;
&lt;li&gt;새로운 임의 접근 시, 2-3을 수행한다.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;여기서 &lt;strong&gt;원소를 옮긴다&lt;/strong&gt;의 의미가, 배열 구조 전체를 수정해야 하는 &lt;strong&gt;제거 후 삽입&lt;/strong&gt;이 아닌, &lt;strong&gt;데이터 스왑&lt;/strong&gt;을 이용한 방식이란 것이 중요하다.&lt;/p&gt;

&lt;p&gt;아래의 그림을 보면 쉽게 이해할 수 있을 것이다.
&lt;img src=&#34;flowchart.png&#34; alt=&#34;배열을 섞는 과정&#34; /&gt;&lt;/p&gt;

&lt;p&gt;바로 코드로 적용해 보자.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-c++&#34;&gt;// arr는 std::vector를 이용한 임의의 배열.

int range = arr.size();
int randomIndex = rand() % range; // [0, range)

// 데이터 스왑.
int temp = arr[randomIndex];
arr[randomIndex] = arr[range - 1];
arr[range - 1] = temp;

--range; // 영역을 줄인다.

arr[range] ...
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;&lt;code&gt;randomIndex&lt;/code&gt;가 가리키는 영역 내의 임의의 원소와 &lt;code&gt;range&lt;/code&gt;가 가리키는 영역 끝의 원소를 스왑함으로써, &lt;code&gt;range&lt;/code&gt;가 영역 내의 임의의 원소를 가리키도록 만들었다.&lt;/p&gt;

&lt;h3 id=&#34;인덱스-배열을-이용:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;인덱스 배열을 이용&lt;/h3&gt;

&lt;p&gt;그러나, 이 방법도 결국 데이터 스왑을 통해 배열에 변형을 가하고 있다.&lt;br /&gt;
위 예제와 같이 원본 배열이 변형되어도 되고, 배열에 저장된 데이터가 레지스터를 이용하는 기본 자료형(&lt;code&gt;int&lt;/code&gt;, &lt;code&gt;char&lt;/code&gt;, &amp;hellip;)이면 전혀 문제될 것이 없지만, 객체와 같이 데이터 스왑에 필요한 비용이 큰 자료형의 경우엔 성능에 크게 영향을 끼칠 것이다. 그러므로 직접 원본 배열을 이용하는 것 보다는, 따로 임의 접근을 위한 인덱스 배열을 두고 이를 섞어 쓰는 편이 낫다.&lt;/p&gt;

&lt;p&gt;물론, 인덱스 배열이 차지하는 메모리도 무시할 수 없지만, 일반적으로 기본 자료형으로 인한 공간 복잡도보다는 객체 복사로 인한 시간 복잡도가 더 큰 문제가 될 것이다.&lt;/p&gt;

&lt;p&gt;다음은 클래스화 한 인덱스 배열의 코드이다.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-c++&#34;&gt;class ShuffledIndices{
private:
    std::vector&amp;lt;int&amp;gt; indices;
    int range;
public:
    ShuffledIndices(int size): indices(size), range(size) {
        for(int i=0; i&amp;lt;size; ++i){
            indices[i] = i;
        }
    }

    int getIndex() {
        int randomIndex = rand() % range; // [0, range)

        // 데이터 스왑.
        int temp = indices[randomIndex];
        indices[randomIndex] = indices[range - 1];
        indices[range - 1] = temp;

        // 영역을 줄인다. 더 이상 접근할 영역이 없으면 초기화 한다.
        if(--range &amp;lt; 1){
            range = indices.size();
        }

        return temp;
    }
};
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;생성자에서 배열과 동일한 크기의 인덱스 배열을 만들고, &lt;code&gt;getIndex()&lt;/code&gt;를 호출할 때마다 임의 접근할 인덱스를 반환한다. 추가된 점은, 더 이상 임의 접근할 영역이 없다면 &lt;code&gt;range&lt;/code&gt;를 초기화 하고, 다시 인덱스 배열 전체를 이용하도록 만든 것이다.&lt;/p&gt;

&lt;p&gt;아래와 같이 쓰면 된다.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-c++&#34;&gt;// arr는 std::vector를 이용한 임의의 배열.

ShuffledIndices si(arr.size());
for(int i=0; i&amp;lt;arr.size(); ++i){
    arr[si.getIndex()] ...
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;배열-섞기:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;배열 섞기&lt;/h2&gt;

&lt;p&gt;목적이 배열을 섞는 것이라면 굳이 인덱스 배열을 쓸 필요가 없다.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-c++&#34;&gt;template &amp;lt;typename type_t&amp;gt;
void shuffle(std::vector&amp;lt;type_t&amp;gt; &amp;amp;arr) {
    int range = arr.size();

    for(int i=0; i&amp;lt;arr.size(); ++i) {
        int randomIndex = rand() % range; // [0, range)

        // 데이터 스왑.
        type_t temp = arr[randomIndex];
        arr[randomIndex] = arr[range - 1];
        arr[range - 1] = temp;

        --range; // 영역을 줄인다.
    }
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;&lt;code&gt;getIndex()&lt;/code&gt;를 조금 변형하여 배열을 섞는 함수를 작성했다. 달라진 점은 원본 배열을 직접 이용한다는 점과 여러 자료형에 적용할 수 있도록 &lt;code&gt;template&lt;/code&gt;을 사용한 것 뿐이다.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>배열 뒤집기</title>
      <link>https://o-tantk.github.io/posts/reverse-array/</link>
      <pubDate>Tue, 20 Sep 2016 01:23:50 +0900</pubDate>
      <author>tantk90@hotmail.com (tantk)</author>
      <guid>https://o-tantk.github.io/posts/reverse-array/</guid>
      <description>

&lt;h1 id=&#34;문제:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;문제&lt;/h1&gt;

&lt;p&gt;배열 안의 데이터 순서를 역순으로 바꾼다고 하자.&lt;br /&gt;
&lt;code&gt;[&#39;a&#39;, &#39;b,&#39; &#39;c&#39;, &#39;d&#39;]&lt;/code&gt;와 같은 배열을 &lt;code&gt;[&#39;d&#39;, &#39;c&#39;, &#39;b&#39;, &#39;a&#39;]&lt;/code&gt;와 같이 뒤집고 싶다는 것이다.&lt;br /&gt;
C#, Python과 같이 사용자 친화적 언어들은 &lt;code&gt;.reverse()&lt;/code&gt;하면 아주 손쉽게 배열을 뒤집을 수 있지만, C와 같은 언어에서는 한 번쯤 생각해 볼 수 있는 문제이다.&lt;/p&gt;

&lt;h2 id=&#34;새로운-배열에-역순으로-복사:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;새로운 배열에 역순으로 복사&lt;/h2&gt;

&lt;p&gt;아마도 가장 단순 무식하게 떠올릴 수 있는 방법은, 똑같은 크기의 배열을 새로 만들어서 역순으로 데이터를 옮기는 것이다.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-c&#34;&gt;char new_array[SIZE];
for(i = 0; i &amp;lt; SIZE; ++i) {
    new_array[SIZE - 1 - i] = old_array[i];
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;간단히 옮기는 것 까지는 좋았는데, 배열 크기 만큼의 새로운 메모리가 필요하다니 낭비가 너무 심하다. 게다가 원본 저장소 &lt;code&gt;old_array&lt;/code&gt;를 그대로 사용하고 싶다면 &lt;code&gt;memcpy&lt;/code&gt;를 추가로 수행해줘야 한다.&lt;/p&gt;

&lt;p&gt;뭐, 위 방법을 쓸리는 없고, 그냥 한 번 생각해보자는 것이니까 다음을 보자.&lt;/p&gt;

&lt;h2 id=&#34;데이터-스왑을-이용:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;데이터 스왑을 이용&lt;/h2&gt;

&lt;p&gt;일반적으로 사용되는 가장 흔한 형태는, 아래와 같이 데이터 스왑을 이용해서 배열을 뒤집는 방법일 것이다.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-c&#34;&gt;char temp;
for(i = 0; i &amp;lt; SIZE / 2; ++i) {
    temp = array[i];
    array[i] = array[SIZE - 1 - i];
    array[SIZE - 1 - i] = temp;
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;배열의 양 끝에서부터 중간 지점까지 각각 차례로 한 칸씩 이동하며 데이터를 교환함으로써 배열의 순서를 뒤집고 있다. 데이터 스왑에는 임시 메모리를 이용한 전형적인 방법이 사용되었다.&lt;br /&gt;
이 정도면 아주 작은 추가 메모리로 원본 저장소도 유지할 수 있고, 연산횟수도 반으로 줄었으니 더할 나위 없어 보인다.&lt;/p&gt;

&lt;p&gt;그러나 모종의 변태들은, 새하얀 도화지의 까만 점 처럼 &lt;code&gt;temp&lt;/code&gt;가 자꾸 눈에 밟히고 치명적인 오점인 것처럼 생각할지도 모른다.&lt;/p&gt;

&lt;h1 id=&#34;배타적-논리합-xor-을-이용한-데이터-스왑:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;배타적 논리합(XOR)을 이용한 데이터 스왑&lt;/h1&gt;

&lt;p&gt;비트 연산 XOR을 이용하면 여분의 메모리를 사용하지 않고도 데이터를 교환할 수 있다.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-c&#34;&gt;char a = &#39;A&#39;, b = &#39;B&#39;;
a ^= b;
b ^= a;
a ^= b;
// DONE. a == &#39;B&#39;, b == &#39;A&#39;.
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;정말 간단하다.&lt;/p&gt;

&lt;p&gt;어떻게 이게 가능한걸까? 이는 배타적 논리합이 갖는, 두 피연산자의 서로 다른 성질만을 남긴다는 점을 교묘하게 이용하고 있기 때문이다.&lt;br /&gt;
a와 b가 집합이라고 생각하고 위의 코드에 대입해보자.
&lt;center&gt;&lt;/p&gt;

&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th align=&#34;left&#34;&gt;과정&lt;/th&gt;
&lt;th align=&#34;left&#34;&gt;a&lt;/th&gt;
&lt;th align=&#34;left&#34;&gt;b&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;

&lt;tbody&gt;
&lt;tr&gt;
&lt;td align=&#34;left&#34;&gt;초기화&lt;/td&gt;
&lt;td align=&#34;left&#34;&gt;(ab 공통의 성질, a의 유일한 성질)&lt;/td&gt;
&lt;td align=&#34;left&#34;&gt;(ab 공통의 성질, b의 유일한 성질)&lt;/td&gt;
&lt;/tr&gt;

&lt;tr&gt;
&lt;td align=&#34;left&#34;&gt;a = a ^ b&lt;/td&gt;
&lt;td align=&#34;left&#34;&gt;(ab 공통, a의 유일) ^ (ab 공통, b의 유일)&lt;br \&gt;= (a의 유일, b의 유일)&lt;/td&gt;
&lt;td align=&#34;left&#34;&gt;(ab 공통의 성질, b의 유일한 성질)&lt;/td&gt;
&lt;/tr&gt;

&lt;tr&gt;
&lt;td align=&#34;left&#34;&gt;b = b ^ a&lt;/td&gt;
&lt;td align=&#34;left&#34;&gt;(a의 유일, b의 유일)&lt;/td&gt;
&lt;td align=&#34;left&#34;&gt;(ab 공통, b의 유일) ^ (a의 유일, b의 유일)&lt;br \&gt;= (ab 공통, a의 유일)&lt;/td&gt;
&lt;/tr&gt;

&lt;tr&gt;
&lt;td align=&#34;left&#34;&gt;a = a ^ b&lt;/td&gt;
&lt;td align=&#34;left&#34;&gt;(a의 유일, b의 유일) ^ (ab 공통, a의 유일)&lt;br \&gt;= (ab 공통, b의 유일)&lt;/td&gt;
&lt;td align=&#34;left&#34;&gt;(ab 공통, a의 유일)&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;

&lt;p&gt;&lt;/center&gt;&lt;/p&gt;

&lt;p&gt;벤 다이어그램으로 그리면 다음과 같다.
&lt;img src=&#34;venn_diagram.png&#34; alt=&#34;데이터 교환 과정&#34; /&gt;&lt;/p&gt;

&lt;p&gt;XOR은 교환 법칙이 성립한다는 것을 이용해 수학적으로 증명할 수도 있다.
&lt;center&gt;&lt;/p&gt;

&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th align=&#34;left&#34;&gt;과정&lt;/th&gt;
&lt;th align=&#34;left&#34;&gt;a&lt;/th&gt;
&lt;th align=&#34;left&#34;&gt;b&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;

&lt;tbody&gt;
&lt;tr&gt;
&lt;td align=&#34;left&#34;&gt;초기화&lt;/td&gt;
&lt;td align=&#34;left&#34;&gt;A&lt;/td&gt;
&lt;td align=&#34;left&#34;&gt;B&lt;/td&gt;
&lt;/tr&gt;

&lt;tr&gt;
&lt;td align=&#34;left&#34;&gt;a = a ^ b&lt;/td&gt;
&lt;td align=&#34;left&#34;&gt;A ^ B&lt;/td&gt;
&lt;td align=&#34;left&#34;&gt;B&lt;/td&gt;
&lt;/tr&gt;

&lt;tr&gt;
&lt;td align=&#34;left&#34;&gt;b = b ^ a&lt;/td&gt;
&lt;td align=&#34;left&#34;&gt;A ^ B&lt;/td&gt;
&lt;td align=&#34;left&#34;&gt;B ^ A ^ B&lt;br \&gt;= A ^ B ^ B (교환 법칙)&lt;br \&gt;= A&lt;/td&gt;
&lt;/tr&gt;

&lt;tr&gt;
&lt;td align=&#34;left&#34;&gt;a = a ^ b&lt;/td&gt;
&lt;td align=&#34;left&#34;&gt;A ^ B ^ A&lt;br \&gt;= A ^ A ^ B (교환 법칙)&lt;br \&gt;= B&lt;/td&gt;
&lt;td align=&#34;left&#34;&gt;A&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;

&lt;p&gt;&lt;/center&gt;&lt;/p&gt;

&lt;h2 id=&#34;다른-자료형에의-적용:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;다른 자료형에의 적용&lt;/h2&gt;

&lt;p&gt;메모리 내용 자체를 교환하는 방식이니까 어떤 데이터든 교환이 가능할까?&lt;br /&gt;
비트 연산은 정수형 자료형만 가능하므로 일반적으로는 다른 자료형에 적용할 수 없지만, 약간의 트릭으로 실수형 자료형과 같은 다른 자료형에도 적용할 수 있다.&lt;/p&gt;

&lt;p&gt;바로 포인터를 이용하는 것이다.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-c++&#34;&gt;float a = 1.0f, b = -1.0f;
*(reinterpret_cast&amp;lt;int *&amp;gt;(&amp;amp;a)) ^= *(reinterpret_cast&amp;lt;int *&amp;gt;(&amp;amp;b));
*(reinterpret_cast&amp;lt;int *&amp;gt;(&amp;amp;b)) ^= *(reinterpret_cast&amp;lt;int *&amp;gt;(&amp;amp;a));
*(reinterpret_cast&amp;lt;int *&amp;gt;(&amp;amp;a)) ^= *(reinterpret_cast&amp;lt;int *&amp;gt;(&amp;amp;b));  
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;캐스트 연산자 때문에 뭔가 복잡해 보이지만, float 자료형이 int 자료형인 것처럼 컴파일러를 속였을 뿐이다.&lt;br /&gt;
비록 정수형 자료형의 크기와 동일한 크기를 가진 자료형만 해당되지만, 어엿하게 실수형 자료형에도 적용할 수 있다는 말이다.&lt;/p&gt;

&lt;h2 id=&#34;xor을-이용하면-더-좋을까:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;XOR을 이용하면 더 좋을까?&lt;/h2&gt;

&lt;p&gt;그렇다면, XOR을 이용한 방식이 정말 더 좋은지 확인해보자.&lt;/p&gt;

&lt;p&gt;먼저 XOR을 이용한 방법의 어셈블리 코드를 보자.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-c++&#34;&gt;; 7    :    *(reinterpret_cast&amp;lt;int *&amp;gt;(&amp;amp;a)) ^= *(reinterpret_cast&amp;lt;int *&amp;gt;(&amp;amp;b));
  00042 8b 45 f4     mov     eax, DWORD PTR _a$[ebp]
  00045 33 45 e8     xor     eax, DWORD PTR _b$[ebp]
  00048 89 45 f4     mov     DWORD PTR _a$[ebp], eax
; 8    :    *(reinterpret_cast&amp;lt;int *&amp;gt;(&amp;amp;b)) ^= *(reinterpret_cast&amp;lt;int *&amp;gt;(&amp;amp;a));
  0004b 8b 45 e8     mov     eax, DWORD PTR _b$[ebp]
  0004e 33 45 f4     xor     eax, DWORD PTR _a$[ebp]
  00051 89 45 e8     mov     DWORD PTR _b$[ebp], eax
; 9    :    *(reinterpret_cast&amp;lt;int *&amp;gt;(&amp;amp;a)) ^= *(reinterpret_cast&amp;lt;int *&amp;gt;(&amp;amp;b));
  00054 8b 45 f4     mov     eax, DWORD PTR _a$[ebp]
  00057 33 45 e8     xor     eax, DWORD PTR _b$[ebp]
  0005a 89 45 f4     mov     DWORD PTR _a$[ebp], eax
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;다음은 임시 메모리를 이용한 방법의 어셈블리 코드이다.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-c++&#34;&gt;; 12   :    temp = a;
  0005d f3 0f 10 45 f4   movss   xmm0, DWORD PTR _a$[ebp]
  00062 f3 0f 11 45 dc   movss   DWORD PTR _temp$[ebp], xmm0
; 13   :    a = b;
  00067 f3 0f 10 45 e8   movss   xmm0, DWORD PTR _b$[ebp]
  0006c f3 0f 11 45 f4   movss   DWORD PTR _a$[ebp], xmm0
; 14   :    b = temp;
  00071 f3 0f 10 45 dc   movss   xmm0, DWORD PTR _temp$[ebp]
  00076 f3 0f 11 45 e8   movss   DWORD PTR _b$[ebp], xmm0
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;전자는 후자에 비해 XOR 연산을 위한 CPU 사이클이 하나씩 더 들어가 있다.&lt;br /&gt;
어셈블리 코드를 볼 줄 모른다고 해도, 척 보면 XOR을 이용한 방식의 코드 길이가 3줄 더 많다는 것을 알 수 있다. 이는 CPU의 연산이 세 번 더 수행된다는 뜻이다.&lt;/p&gt;

&lt;p&gt;실제로 얼마나 성능 차가 나는지 실험 결과를 보자.&lt;br /&gt;
다음은 특정 배열에 대해 무작위(&lt;a href=&#34;https://ko.wikipedia.org/wiki/분기_예측&#34;&gt;분기 예측&lt;/a&gt; 방지) 원소 교환을 9999999회 수행하는데 걸린 시간이다. (3.3Ghz CPU)
&lt;center&gt;&lt;/p&gt;

&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th align=&#34;left&#34;&gt;방법&lt;/th&gt;
&lt;th align=&#34;center&#34;&gt;소요 시간&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;

&lt;tbody&gt;
&lt;tr&gt;
&lt;td align=&#34;left&#34;&gt;XOR&lt;/td&gt;
&lt;td align=&#34;center&#34;&gt;42 ms&lt;/td&gt;
&lt;/tr&gt;

&lt;tr&gt;
&lt;td align=&#34;left&#34;&gt;임시 메모리&lt;/td&gt;
&lt;td align=&#34;center&#34;&gt;15 ms&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;

&lt;p&gt;&lt;/center&gt;
확실히 임시 메모리를 이용한 방법이 더 빠르긴 하지만, 이 정도의 미미한 차이는 무시할 수 있는 수준이다.&lt;/p&gt;

&lt;h1 id=&#34;결론:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;결론&lt;/h1&gt;

&lt;p&gt;어째 의식이 흐르듯 배열 뒤집기에서 데이터 스왑으로 주제가 바뀐 것 같지만&amp;hellip;&lt;/p&gt;

&lt;p&gt;아무튼 결론적으로 얘기하자면, 배열을 뒤집을 땐 데이터 스왑을 이용한 방식으로 구현하는 것이 좋고, 데이터 스왑 방식으로는 임시 메모리를 이용하든 XOR을 이용하든 개발자 마음대로 라는 것이다.&lt;br /&gt;
XOR을 이용한 방식은, 알아두면 &amp;lsquo;이렇게 변태같이 데이터 스왑하는 방법도 있다!&amp;rsquo; 하고 자랑할 수도 있다.&lt;/p&gt;

&lt;p&gt;물론, 영상처리와 같이 10ms가 아쉬운 경우라면 임시 메모리를 이용한 방법이 더 적절하겠지만 말이다.&lt;/p&gt;

&lt;h1 id=&#34;references:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;References&lt;/h1&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://ko.wikipedia.org/wiki/XOR_교체_알고리즘&#34;&gt;https://ko.wikipedia.org/wiki/XOR_교체_알고리즘&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</description>
    </item>
    
    <item>
      <title>콘솔 프로그램 실행기</title>
      <link>https://o-tantk.github.io/posts/console-app-launcher/</link>
      <pubDate>Fri, 17 Jun 2016 15:40:57 +0900</pubDate>
      <author>tantk90@hotmail.com (tantk)</author>
      <guid>https://o-tantk.github.io/posts/console-app-launcher/</guid>
      <description>

&lt;h1 id=&#34;사설:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;사설&lt;/h1&gt;

&lt;p&gt;영상처리 과제를 할 때였다. 알고리즘의 파라미터를 다양하게 변화시켜 그에 따른 여러 결과를 보여야 했다.&lt;br /&gt;
그런데, 윈도우에서 콘솔 프로그램의 파라미터를 계속 바꾸는 것이 여간 귀찮은게 아니었다. 특히 실행이 끝나면 무의식적으로 cmd 창을 끄는 버릇 때문에, 다시 cmd 창을 켜고 실행 파일 위치까지 이동하는 과정이 너무 귀찮았다.&lt;/p&gt;

&lt;p&gt;Batch 파일은 작성하는 방법을 제대로 알지 못했고, 입력 파라미터가 정해진게 아니어서 미리 작업를 예약하는 방식은 쓸 수 없었다.
그렇다고 콘솔 프로그램을 GUI로 새로 작성하기에는 시간이 아깝다.&lt;/p&gt;

&lt;p&gt;결국 C# winform을 이용해, 콘솔 프로그램의 위치를 기억하고 파라미터를 입력할 수 있는 간단한 프로그램을 작성하기로 했다.&lt;/p&gt;

&lt;h1 id=&#34;프로그램:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;프로그램&lt;/h1&gt;

&lt;p&gt;&lt;img src=&#34;app.png&#34; alt=&#34;프로그램 스크린샷&#34; /&gt;
&lt;center&gt;&lt;a href=&#34;https://github.com/o-tantk/ConsoleAppLauncher&#34;&gt;https://github.com/o-tantk/ConsoleAppLauncher&lt;/a&gt;&lt;/center&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;콘솔 프로그램의 위치와 입력했던 파라미터를 기억한다.&lt;/li&gt;
&lt;li&gt;콘솔 프로그램의 실행 및 파라미터 입력을 GUI 환경에서 수행한다.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&#34;파라미터-입력-및-실행:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;파라미터 입력 및 실행&lt;/h2&gt;

&lt;p&gt;내가 원했던 것은, 콘솔 프로그램에 파라미터를 입력하고 실행하면 그 실행 내용과 결과가 cmd 창에 출력되는 모습이었는데, &lt;code&gt;System.Diagnotics.Process&lt;/code&gt;로 콘솔 프로그램을 직접 실행시켰더니 프로그램 종료와 함께 cmd 창이 닫혔다.&lt;br /&gt;
그래서, cmd부터 실행시키고 cmd에서 콘솔 프로그램을 실행시키는 방향으로 설계해야 했으며, 이는 콘솔 프로그램 및 파라미터가 담긴 명령줄을 cmd의 파라미터로 실행하여 해결했다.&lt;/p&gt;

&lt;p&gt;&lt;a href=&#34;https://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/cmd.mspx?mfr=true&#34;&gt;cmd의 옵션&lt;/a&gt;을 확인해 보니, cmd에 명령줄을 전달하려면 &lt;code&gt;/c&lt;/code&gt; 또는 &lt;code&gt;/k&lt;/code&gt; 옵션을 이용하면 된다.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;/c : Carries out the command specified by string and then stops.&lt;br /&gt;
/k : Carries out the command specified by string and continues.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;둘 중 무슨 옵션을 이용해야 할까? 바로 창이 닫히는게 문제니까 &lt;code&gt;/k&lt;/code&gt; 옵션을 쓰는게 좋을까? 그러나 &lt;code&gt;/k&lt;/code&gt; 옵션을 이용하면 프로그램 종료 후 다음 명령을 기다리는 프롬프트 화면으로 넘어가기 때문에 창을 수작업으로 닫아줘야 한다. 결과 확인만 하면 되는데 귀찮은 작업이 늘어난다.&lt;/p&gt;

&lt;p&gt;결국 &lt;code&gt;/c&lt;/code&gt; 옵션을 이용해야 하는데, &amp;lsquo;계속하려면 아무키나 누르세요&amp;rsquo;를 띄우는게 좋겠다.&lt;br /&gt;
처음 코딩을 배울 때 꼼수로 애용했던 &lt;code&gt;pause&lt;/code&gt;를 이용하자. cmd를 띄우는 명령과 함께 사용해야 하니 &lt;code&gt;&amp;amp;&lt;/code&gt;를 이용하면 된다. (여러 명령을 함께 실행하는 방법은 &lt;a href=&#34;https://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/ntcmds_shelloverview.mspx?mfr=true&#34;&gt;여기&lt;/a&gt;를 참조)&lt;/p&gt;

&lt;p&gt;명령줄은 다음과 같을 것이다.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-nohighlight&#34;&gt;# cmd.exe /c myapp.exe -myparam &amp;amp; pause
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;이를 C# Winform에서 실행해 보자.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-C#&#34;&gt;// using System.Diagnotics;
// appPath: 프로그램 경로. ex) &amp;quot;c:\myapp.exe&amp;quot;
// tb_parameters: 파라미터가 입력된 Textbox.

Process app = new Process();
app.StartInfo.FileName = &amp;quot;cmd.exe&amp;quot;;
app.StartInfo.Arguments = &amp;quot;/C &amp;quot; + appPath + &amp;quot; &amp;quot; + tb_parameters.Text + &amp;quot;&amp;amp; pause&amp;quot;;
app.Start();
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;이때, &lt;code&gt;Process&lt;/code&gt;의 작업 디렉토리를 설정해주지 않으면 콘솔 프로그램 &lt;strong&gt;실행기의 위치&lt;/strong&gt;가 작업 디렉토리가 되므로, &lt;code&gt;System.IO.Path.GetDirectoryName&lt;/code&gt;으로 콘솔 프로그램의 위치를 가져와 작업 디렉토리로 설정해주자.&lt;/p&gt;

&lt;p&gt;한 줄만 추가해 주면 된다.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-C#&#34;&gt;// using System.IO;

app.StartInfo.WorkingDirectory = Path.GetDirectoryName(appPath);
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;레지스트리-저장:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;레지스트리 저장&lt;/h2&gt;

&lt;p&gt;실행했던 콘솔 프로그램의 위치와 파라미터의 기억은 레지스트리를 이용한다.&lt;/p&gt;

&lt;p&gt;레지스트리의 저장 위치는 &lt;code&gt;LOCAL_MACHINE&lt;/code&gt;과 &lt;code&gt;CURRENT_USER&lt;/code&gt;의 두 가지 선택지가 존재하는데, &lt;code&gt;LOCAL_MACHINE&lt;/code&gt;은 컴퓨터 전역 / 모든 사용자에게 적용되는 필드로 저장할 때 관리자 권한을 요구한다. &lt;code&gt;CURRENT_USER&lt;/code&gt;는 사용자 계정에 종속되는 필드로 프로그램의 환경 설정을 저장할 때 일반적으로 사용된다.&lt;/p&gt;

&lt;p&gt;콘솔 프로그램 실행기는 특별한 정보를 저장하는 것이 아니니 &lt;code&gt;CURRENT_USER&lt;/code&gt; 필드를 이용한다.&lt;br /&gt;
그리고, 일반 소프트웨어는 보통 &lt;code&gt;Software&lt;/code&gt; 필드를 이용하므로 서브 키를 &lt;code&gt;Software\\AppLauncher&lt;/code&gt;로 만들자.&lt;br /&gt;
C# 코드 상에선 다음과 같다.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-C#&#34;&gt;// using Microsoft.Win32;

RegistryKey subkey = Registry.CurrentUser.OpenSubKey(&amp;quot;Software\\AppLauncher&amp;quot;, true);
// 먼저 OpenSubKey로 이미 서브 키가 있는지 확인한다.
// 쓰기를 수행하려면 두 번째 인자로 true를 넘겨줘야 한다.
if (subkey == null)
{
    subkey = Registry.CurrentUser.CreateSubKey(&amp;quot;Software\\AppLauncher&amp;quot;);
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;레지스트리에 저장할 것은 프로그램의 경로와 파라미터이다. 두 값 모두 &lt;code&gt;string&lt;/code&gt;이므로 &lt;code&gt;RegistryValueKind.String&lt;/code&gt;으로 지정하여 저장한다.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-C#&#34;&gt;subkey.SetValue(&amp;quot;AppPath&amp;quot;, appPath, RegistryValueKind.String);
subkey.SetValue(&amp;quot;Parameters&amp;quot;, tb_parameters.Text, RegistryValueKind.String);
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;레지스트리를 가져올 때는, &lt;code&gt;object&lt;/code&gt; 객체를 반환하는 &lt;code&gt;RegistryKey.GetValue&lt;/code&gt;를 이용한다.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-C#&#34;&gt;// using Microsoft.Win32;

RegistryKey subkey = Registry.CurrentUser.OpenSubKey(&amp;quot;Software\\AppLauncher&amp;quot;);
if (subkey != null)
{
    appPath = subkey.GetValue(&amp;quot;AppPath&amp;quot;).ToString();
    tb_parameters.Text = subkey.GetValue(&amp;quot;Parameters&amp;quot;).ToString(); 
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;끝:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;끝&lt;/h2&gt;

&lt;p&gt;핵심 기능을 구현하는 법은 알았으니 프로그램 구조를 적절히 설계만 하면 된다.&lt;/p&gt;

&lt;p&gt;콘솔 프로그램을 실행하는 부분은 실행 버튼의 &lt;code&gt;Click&lt;/code&gt; 이벤트에 구현하면 될 것이고&amp;hellip;&lt;br /&gt;
레지스트리를 가져올 때는 &lt;code&gt;Load&lt;/code&gt; 이벤트를, 기록할 때는 &lt;code&gt;Form_Closed&lt;/code&gt;를 이용하자.&lt;/p&gt;

&lt;h1 id=&#34;references:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;References&lt;/h1&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;http://www.differencebetween.net/technology/hardware-technology/difference-between-hkey_current_user-and-hkey_local_machine/&#34;&gt;http://www.differencebetween.net/technology/hardware-technology/difference-between-hkey_current_user-and-hkey_local_machine/&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</description>
    </item>
    
    <item>
      <title>Search</title>
      <link>https://o-tantk.github.io/search/</link>
      <pubDate>Wed, 15 Jun 2016 04:50:09 +0900</pubDate>
      <author>tantk90@hotmail.com (tantk)</author>
      <guid>https://o-tantk.github.io/search/</guid>
      <description></description>
    </item>
    
    <item>
      <title>About</title>
      <link>https://o-tantk.github.io/about/</link>
      <pubDate>Mon, 02 May 2016 02:06:32 +0900</pubDate>
      <author>tantk90@hotmail.com (tantk)</author>
      <guid>https://o-tantk.github.io/about/</guid>
      <description>

&lt;h1 id=&#34;tantk-땅꾸:6083a88ee3411b0d17ce02d738f69d47&#34;&gt;tantk == 땅꾸&lt;/h1&gt;

&lt;p&gt;Game developer. Otaku.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Programmer, devCat Studio, Nexon. 2017 ~&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&#34;feel-free-to-contact:6083a88ee3411b0d17ce02d738f69d47&#34;&gt;Feel free to contact&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;i class=&#34;fa fa-envelope&#34;&gt;&lt;/i&gt; &lt;a href=&#34;mailto:tantk90@hotmail.com&#34;&gt;tantk90 at hotmail.com&lt;/a&gt;&lt;br /&gt;&lt;/li&gt;
&lt;li&gt;&lt;i class=&#34;fa fa-github&#34;&gt;&lt;/i&gt; &lt;a href=&#34;https://github.com/o-tantk&#34;&gt;o-tantk at Github&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&#34;skills:6083a88ee3411b0d17ce02d738f69d47&#34;&gt;Skills&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Languages: C++(Primary), C, C#, GLSL, Lua, CUDA, &amp;hellip;&lt;br /&gt;&lt;/li&gt;
&lt;li&gt;Frameworks: STL, OpenGL, Unity3D, &amp;hellip;&lt;/li&gt;
&lt;/ul&gt;
</description>
    </item>
    
    <item>
      <title>땅꾸의 블로그</title>
      <link>https://o-tantk.github.io/posts/hello-world/</link>
      <pubDate>Mon, 02 May 2016 02:06:23 +0900</pubDate>
      <author>tantk90@hotmail.com (tantk)</author>
      <guid>https://o-tantk.github.io/posts/hello-world/</guid>
      <description>

&lt;h1 id=&#34;안녕하세요-땅꾸입니다:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;안녕하세요. 땅꾸입니다.&lt;/h1&gt;

&lt;p&gt;이 블로그는 &lt;a href=&#34;https://gohugo.io/&#34;&gt;Hugo&lt;/a&gt;라는 Static Website Engine을 이용해서 만들었고, &lt;a href=&#34;https://github.com/&#34;&gt;Github&lt;/a&gt;를 이용해 호스팅 하고 있습니다.&lt;/p&gt;

&lt;h1 id=&#34;이-아래는-markdown-문서의-테스트이므로-무시하셔도-좋습니다:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;이 아래는 markdown 문서의 테스트이므로 무시하셔도 좋습니다.&lt;/h1&gt;

&lt;p&gt;Windows OS의 경로 최대길이는 &lt;code&gt;MAX_PATH&lt;/code&gt;라는 상수값 260으로 제한되어 있다.&lt;/p&gt;

&lt;p&gt;{{//&amp;lt; tweet 742203311508443136 &amp;gt;}}&lt;/p&gt;

&lt;p&gt;다음은 c++ 코드 샘플&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-c++&#34;&gt;#include &amp;lt;iostream&amp;gt;
int main(int argc, char **argv){
    std::cout &amp;lt;&amp;lt; &amp;quot;hello world!&amp;quot; &amp;lt;&amp;lt; std::endl;
    return 0;
}
// 코드는 어디까지 길어질까아ㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏ 는 highlight.js는 자동 줄넘김이다.
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;다음은 glsl 코드 샘플&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-glsl&#34;&gt;layout(location=0) in vec3 position;

void main(void){
    gl_Position = position;
}
&lt;/code&gt;&lt;/pre&gt;


&lt;div style=&#34;position: relative; padding-bottom: 56.25%; padding-top: 30px; height: 0; overflow: hidden;&#34;&gt;
  &lt;iframe src=&#34;//www.youtube.com/embed/KXSUEU7ISfQ&#34; style=&#34;position: absolute; top: 0; left: 0; width: 100%; height: 100%;&#34; allowfullscreen frameborder=&#34;0&#34;&gt;&lt;/iframe&gt;
 &lt;/div&gt;


&lt;p&gt;
&lt;figure &gt;
    
        &lt;img src=&#34;%ed%98%b8%eb%ac%b4%ed%98%b8%eb%ac%b4.jpg&#34; alt=&#34;호무호무&#34; /&gt;
    
    
    &lt;figcaption&gt;
        호무호무한 호무라짱
        
    &lt;/figcaption&gt;
    
&lt;/figure&gt;


위의 호무호무한 호무라짱을 보라! 너무나도 호무호무하다. 호무호무&amp;hellip;&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;호무호무는 너무나도 호무호무하기에 인용까지 해야 할 정도이다.&lt;br /&gt;
두 번째 인용 줄&lt;/p&gt;

&lt;p&gt;세 번째 인용 줄&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;인용문 끝.&lt;/p&gt;

&lt;h3 id=&#34;shibe-doge:d680e8a854a7cbad6d490c445cba2eba&#34;&gt;Shibe doge&lt;/h3&gt;

&lt;p&gt;본 김에 시베도 보자
&lt;img src=&#34;시베.jpg&#34; alt=&#34;shibe doge&#34; /&gt;
such wow&lt;/p&gt;
</description>
    </item>
    
  </channel>
</rss>