기다림과 눈물

binary indexed tree 구현

바보세룐 — Tue, 15 Sep 2015 21:45:15 +0900

binary indexed tree 에 대한 설명 :

[1] https://en.wikipedia.org/wiki/Fenwick_tree

[2] https://www.topcoder.com/community/data-science/data-science-tutorials/binary-indexed-%20trees/

트리 생성 (update)

void update(int x, int value) {
    while (x <= n) {
        tree[x] += value;
        x += -x&x;
    }
}

구간 합 [1, x]

int sum_from_1_to(int x) {
    int s(0);
    while (x) {
        s += tree[x];
        x &= x - 1;
    }
    return s;
}

파일 로깅

바보세룐 — Thu, 10 Sep 2015 17:07:09 +0900

테스트 할 때 로그를 출력하기 거시기 할 때 그냥 파일에 쓰게 간단히 코드를 만들어 둠.

#ifndef _BABO_LOG_H
#define _BABO_LOG_H
 
#include <cstdio>
#include <cstdarg>
#include <fstream>
 
using namespace std;
 
class Log {
private:
    Log() { file.open("/var/log/log.txt", ios::out | ios::app); } // 파일에 계속 이어 붙인다.
    ~Log() { file.close(); }
    ofstream file;
public:
    static Log &instance() { // singleton
        static Log _instance;
        return _instance;
    }
    void log(const char *format, ...) {
        char buffer[256];
        va_list args;
        va_start(args, format);
        vsnprintf(buffer, sizeof(buffer), format, args);
        va_end(args);
        file << buffer;
    }
};
 
#define log(format, args...) Log::instance().log(format, ##args)
 
#endif // _BABO_LOG_H

다음과 같이 사용하면 된다.

#include "Log.h"
 
int main() {
    for (int i = 0; i < 10; i++)
        log("%d\n", i);
    return 0;
}

c++11 pair<> class

바보세룐 — Fri, 4 Sep 2015 14:20:45 +0900

pair<> 클래스

pair 는 c++98 에도 이미 제공되고 있었다.

pair 는 두 객체를 하나의 타입으로 묶어 사용한다.

예를들면, 2차원 평면 상에서 좌표를 표현하는 경우 다음과 같이 사용할 수 있다.

pair<int, int> 2d_point;

또 map 계열의 클래스는 키와 값의 쌍으로 구성되는데 이때도 pair 를 사용한다.

각 타입은 template 으로 정의 되므로 다른 타입이 사용될 수 있다.

pair 를 선언을 하면 선언 시에 사용된 객체의 default constructor 가 불리며 int 와 같은 primitive 타입이라면 0 으로 초기화 된다.

pair 정의 코드

bits/stl_pair.h g++ (GCC) 4.8.2

/**
   *  @brief Struct holding two objects of arbitrary type.
   *
   *  @tparam _T1  Type of first object.
   *  @tparam _T2  Type of second object.
   */
  template<class _T1, class _T2>
    struct pair
    {
      typedef _T1 first_type;    /// @c first_type is the first bound type
      typedef _T2 second_type;   /// @c second_type is the second bound type
      _T1 first;                 /// @c first is a copy of the first object
      _T2 second;                /// @c second is a copy of the second object
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 265.  std::pair::pair() effects overly restrictive
      /** The default constructor creates @c first and @c second using their
       *  respective default constructors.  */
      _GLIBCXX_CONSTEXPR pair()
      : first(), second() { }
      /** Two objects may be passed to a @c pair constructor to be copied.  */
      _GLIBCXX_CONSTEXPR pair(const _T1& __a, const _T2& __b)
      : first(__a), second(__b) { }
      /** There is also a templated copy ctor for the @c pair class itself.  */
#if __cplusplus < 201103L
      template<class _U1, class _U2>
    pair(const pair<_U1, _U2>& __p)
    : first(__p.first), second(__p.second) { }
#else
      template<class _U1, class _U2, class = typename
           enable_if<__and_<is_convertible<const _U1&, _T1>,
                is_convertible<const _U2&, _T2>>::value>::type>
    constexpr pair(const pair<_U1, _U2>& __p)
    : first(__p.first), second(__p.second) { }
      constexpr pair(const pair&) = default;
      constexpr pair(pair&&) = default;
 
 
      // DR 811.
      template<class _U1, class = typename
           enable_if<is_convertible<_U1, _T1>::value>::type>
    constexpr pair(_U1&& __x, const _T2& __y)
    : first(std::forward<_U1>(__x)), second(__y) { }
      template<class _U2, class = typename
           enable_if<is_convertible<_U2, _T2>::value>::type>
    constexpr pair(const _T1& __x, _U2&& __y)
    : first(__x), second(std::forward<_U2>(__y)) { }
      template<class _U1, class _U2, class = typename
           enable_if<__and_<is_convertible<_U1, _T1>,
                is_convertible<_U2, _T2>>::value>::type>
    constexpr pair(_U1&& __x, _U2&& __y)
    : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
      template<class _U1, class _U2, class = typename
           enable_if<__and_<is_convertible<_U1, _T1>,
                is_convertible<_U2, _T2>>::value>::type>
    constexpr pair(pair<_U1, _U2>&& __p)
    : first(std::forward<_U1>(__p.first)),
      second(std::forward<_U2>(__p.second)) { }
      template<typename... _Args1, typename... _Args2>
        pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);
      pair&
      operator=(const pair& __p)
      {
    first = __p.first;
    second = __p.second;
    return *this;
      }
 
 
      template<class _U1, class _U2>
    pair&
    operator=(const pair<_U1, _U2>& __p)
    {
      first = __p.first;
      second = __p.second;
      return *this;
    }
      template<class _U1, class _U2>
    pair&
    operator=(pair<_U1, _U2>&& __p)
    {
      first = std::forward<_U1>(__p.first);
      second = std::forward<_U2>(__p.second);
      return *this;
    }
      void
      swap(pair& __p)
      noexcept(noexcept(swap(first, __p.first))
           && noexcept(swap(second, __p.second)))
      {
    using std::swap;
    swap(first, __p.first);
    swap(second, __p.second);
      }
    private:
      template<typename... _Args1, std::size_t... _Indexes1,
               typename... _Args2, std::size_t... _Indexes2>
        pair(tuple<_Args1...>&, tuple<_Args2...>&,
             _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>);
#endif
    };

pair 는 c++11 에서 크게 확장된 것은 없지만 표준 확장에 따라 move constructor 가 제공되고 swap() 이 추가되었다.

그 외 사용법은 c++98 에 비해 크게 달라진 점은 없다.

멈버 변수인 first 와 second 가 public 으로 선언되어 있기 때문에 접근 제한 없이 사용할 수 있다.

pair 를 간단히 생성하기 위해서 make_pair() 라는 함수가 존재한다.

make_pair 는 객체 생성을 위해 따로 타입을 쓰지 않아도 된다.

make_pair

pair<int, float> int_float(0, 0.0f);

위 코드 대신 아래와 같이 사용할 수 있다.

make_pair

auto int_float = make_pair(0, 0.0f);

make_pair 의 코드:

bits/stl_pair.h g++ (GCC) 4.8.2

c++11 의 make_pair 는 rvalue 인자를 받으므로,

해당 타입이 move semantics 를 지원한다면 인자로 전달된 객체가 변경된다.

간단한 테스트 코드 :

example : make_pair

#include <iostream>
#include <vector>
#include <utility>
using namespace std;
 
void print(const vector<int> &v) {
    cout << "[ ";
    for (auto i : v) {
        cout << i << " ";
    }  
    cout << " ]" << endl;
}
 
int main() {
    vector<int> a;
    a.push_back(1);
    a.push_back(2);
 
    print(a);
    vector<int> b;
    b.push_back(10);
    b.push_back(20);
    print(b);
 
    auto c = make_pair(move(a), move(b)); // 이제 a 와 b 를 사용하지 않는다
    print(a);
    print(b);
    return 0;
}

출력 결과

[ 1 2  ]
[ 10 20  ]
[  ]
[  ]

sublime text 2 plugin development

바보세룐 — Tue, 1 Sep 2015 16:36:48 +0900

http://www.sublimetext.com/docs/plugin-basics

http://code.tutsplus.com/tutorials/how-to-create-a-sublime-text-2-plugin--net-22685

http://code.tutsplus.com/tutorials/sublime-text-2-tips-and-tricks--net-21519

examples :

http://www.sublimetext.com/docs/plugin-examples

api references :

http://www.sublimetext.com/docs/api-reference

대략의 설명

패키지는 폴더로 만들어 져서 Package 디렉토리에 넣으면 된다.

나의 패키지는 "Preferences > Browse Packages…" 메뉴를 통해 들어가면 된다.

패키지는 zip 파일로 묶은 다음 확장자를 .sublime-package 로 바꿔 단일 파일로 사용 가능하다.

보통 language 관련 패키지가 있고, 그 외 Default, User 패키지가 있다.

Default : 모든 표준 키 바인딩, 메뉴 정의, 파일 설정, 파이썬으로 만든 모든 플러그인
User : 마지막에 로딩 되어 기본 값들을 덮어 씀

기본 구현

Tools > New Plugin... 메뉴 선택

import sublime, sublime_plugin
 
class ExampleCommand(sublime_plugin.TextCommand):
    def run(self, edit):
        self.view.insert(edit, 0, "Hello, World!")

바로 이런 게 생긴다.

일단 Packages/ 에서 폴더를 하나 만들고 그 안에 py 파일로 저장한다.

파일 이름은 뭐든 관계 없고, 관례적으로 플러그인 이름을 사용한다.

저장이 되었으면, 콘솔을 열고 (단축키 : Ctrl + ' ) 다음과 같이 입력하면

view.run_command('example')

파일 첫 부분에 "Hello World" 가 삽입된다.

Command Type

Sublime plugin 은 다음 세 가지 command type 을 제공한다.

Text Commands : View 오브젝트를 통해 file 이나 buffer 에 접근
Window Commands : Window 오브젝트를 통해 현재 창을 참조
Applications Commands : 위 두가지에 속 하지 않는.

import sublime, sublime_plugin
class ExampleCommand(sublime_plugin.TextCommand):
    def run(self, edit):
        self.view.insert(edit, 0, "Hello, World!")

sublime_plugin.TextCommand 를 상속 받은 class 의 이름에서 'Command' 를 제외한 나머지 부분,

CamelCase 형식의 이름을 under_score 형식으로 변경한 것이 커맨드 이름이 된다.

(예를 들면, 클래스 이름이 MyOwnCommand 라면 my_own 이 커맨드 이름이 된다.)

단축키 추가하기

패키지 안에 다음과 같이 파일을 추가한다.

MyPackage/
    Default (Linux).sublime-keymap
    Default (OSX).sublime-keymap
    Default (Windows).sublime-keymap

Preferences > Key Bindings – Default 를 통해 겹치지 않는 단축키를 택하면 된다.

다음과 같이 추가하면 된다.

[
    {
        "keys": ["ctrl+alt+x"], "command": "command_name" 
    }
]

커맨드의 인자가 필요하면 뒤에다 arg 로 붙인다.

OSX 에서 커맨드 키는 super 라고 쓴다.

메뉴 추가하기

대략 .sublime-menu 파일을 만들면 된다.

Main.sublime-menu : 메인 메뉴
Side Bar.sublime-menu : 파일이나 폴더에서 오른쪽 클릭 후 팝업 메뉴
Context.sublime-menu : 에디터에서 오른쪽 클릭 후 팝업 메뉴

[
{
    "id": "edit",
    "children":
    [
        {"id": "wrap"},
        { "command": "prefixr" }
    ]
}
]

Modular multiplicative inverse

바보세룐 — Fri, 21 Aug 2015 10:45:29 +0900

references :

https://en.wikipedia.org/wiki/Modular_multiplicative_inverse

In modular arithmetic, the modular multiplicative inverse of an integer a modulo m is an integer x such that

That is, it is the multiplicative inverse in the ring of integers modulo m, denoted .

Once defined, x may be noted , where the fact that the inversion is m-modular is implicit.

The multiplicative inverse of a modulo m exists if and only if a and m are coprime (i.e., if gcd(a, m) = 1).^[1] If the modular multiplicative inverse of a modulo m exists, the operation of divisionby a modulo m can be defined as multiplying by the inverse, which is in essence the same concept as division in the field of reals.

[wiki]

example :

http://codeforces.com/contest/560/problem/E

test code :

are each number of factorial series and 10e9+7 coprime ?

extended Euclidean algorithm

The modular multiplicative inverse of a modulo m can be found with the extended Euclidean algorithm.

The algorithm finds solutions to Bézout's identity

한국어: https://medium.com/@jongukim/extended-euclidean-algorithm-8101bafb9164

test codes:

#include <iostream>
using namespace std;
void cal(int quotient , int &r, int &new_r) {
    int temp(r);
    r = new_r;
    new_r = temp - quotient * new_r;
}
int inverse(int a, int m) {
    int t(0), new_t(1), r(m), new_r(a);
    while (new_r) {
        int quotient = r / new_r;
        cal(quotient, t, new_t);
        cal(quotient, r, new_r);
    }
    if (r > 1) return -1; // something wrong
    if (t < 0) t = t + m;
    return t;
}
int main() {
    while (true) {
        int a, b;
        cin >> a >> b;
        if (a == 0) break;
        cout << inverse(a, b) << endl;
    }
    return 0;
}

dijkstra algorithm and its implementation

바보세룐 — Thu, 20 Aug 2015 18:23:42 +0900

wiki : http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm

특정 두 노드 간의 최단 거리를 구하는 데 사용함.

distance 가 양수 값을 가지는 경우에만 적용.

알고리즘:

아래 알고리즘에서 u := Extract_Min(Q)는 점의 집합 Q에서 가장 작은 d[u]값을 찾은 다음 그 점 u를 Q에서 제거한 후 반환하는 함수를 가리킨다.

function Dijkstra(G, w, s)
  for each vertex v in V[G]                        // 초기화
        d[v] := infinity
        previous[v] := undefined
  d[s] := 0
  S := empty set
  Q := set of all vertices
  while Q is not an empty set                      // 알고리즘의 실행
        u := Extract_Min(Q)
       S := S union {u}
       for each edge (u,v) outgoing from u
              if d[v] > d[u] + w(u,v)             // (u,v)의 경감
                    d[v] := d[u] + w(u,v)
                    previous[v] := u                     //경로 추적할 때 쓰임//

만약 모든 v에 대해서가 아니라 특정한 s에서 t까지의 최단 거리만을 알고 싶다면 9번째 행에서 u = t일 때 종료하면 된다.

s에서 t까지의 최단 경로는 다음과 같이 얻을 수 있다.

S := empty sequence
u := t
while defined u
      insert u to the beginning of S
      u := previous[u]

이제 S는 s에서 t까지의 최단경로 상에 있는 점들의 목록이 된다.

문제 :

Extract_Min() 를 구현하는 방법

소스 코드:

class Line { public:
    Line(int t, int c) : to(t), cost(c) {}
    int to, cost;
    bool operator <(const Line& l) const { return to < l.to; }
};
int n;
bool visit[10000];
vector<Line> line[10000];
class Node { public:
    Node(int i, int c) : index(i), cost(c) {}
    int index, cost;
    bool operator >(const Node& l) const {
        return cost > l.cost;
    }
};
void dijkstra() {
    int i;
    memset(visit, 0, sizeof(bool) * 10000);
    priority_queue<Node, vector<Node>, greater<Node> > Q;
    Q.push(Node(0, 0));
    int solution = 0;
    while (!Q.empty()) {
        Node node = Q.top();
        Q.pop();
        if (visit[node.index]) continue;
        if (node.index == n-1) {
            solution = node.cost;
            break;
        }
        visit[node.index] = true;
        vector<Line>::const_iterator it = line[node.index].begin();
        for (; it != line[node.index].end(); it++) {
            if (!visit[it->to]) {
                Q.push(Node(it->to, node.cost + it->cost));
            }
        }
    }
    cout << solution << endl;
    for (i = 0; i < n; i++) { // release
        line[i].clear();
    }
}

secure socket programming

바보세룐 — Tue, 11 Aug 2015 14:00:30 +0900

secure socket programming

server

Collapse source

//SSL-Server.c
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <malloc.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <resolv.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
  
#define FAIL    -1
  
int OpenListener(int port)
{   int sd;
    struct sockaddr_in addr;
  
    sd = socket(PF_INET, SOCK_STREAM, 0);
    bzero(&addr, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr.s_addr = INADDR_ANY;
    if ( bind(sd, (struct sockaddr*)&addr, sizeof(addr)) != 0 )
    {
        perror("can't bind port");
        abort();
    }
    if ( listen(sd, 10) != 0 )
    {
        perror("Can't configure listening port");
        abort();
    }
    return sd;
}
  
SSL_CTX* InitServerCTX(void)
{   SSL_METHOD *method;
    SSL_CTX *ctx;
  
    OpenSSL_add_all_algorithms();  /* load & register all cryptos, etc. */
    SSL_load_error_strings();   /* load all error messages */
    method = SSLv23_server_method();  /* create new server-method instance */
    ctx = SSL_CTX_new(method);   /* create new context from method */
    if ( ctx == NULL )
    {
        ERR_print_errors_fp(stderr);
        abort();
    }
    return ctx;
}
  
void LoadCertificates(SSL_CTX* ctx, char* CertFile, char* KeyFile)
{
 /* set the local certificate from CertFile */
    if ( SSL_CTX_use_certificate_file(ctx, CertFile, SSL_FILETYPE_PEM) <= 0 )
    {
        ERR_print_errors_fp(stderr);
        abort();
    }
    /* set the private key from KeyFile (may be the same as CertFile) */
    if ( SSL_CTX_use_PrivateKey_file(ctx, KeyFile, SSL_FILETYPE_PEM) <= 0 )
    {
        ERR_print_errors_fp(stderr);
        abort();
    }
    /* verify private key */
    if ( !SSL_CTX_check_private_key(ctx) )
    {
        fprintf(stderr, "Private key does not match the public certificate\n");
        abort();
    }
}
  
void ShowCerts(SSL* ssl)
{   X509 *cert;
    char *line;
  
    cert = SSL_get_peer_certificate(ssl); /* Get certificates (if available) */
    if ( cert != NULL )
    {
        printf("Server certificates:\n");
        line = X509_NAME_oneline(X509_get_subject_name(cert), 0, 0);
        printf("Subject: %s\n", line);
        free(line);
        line = X509_NAME_oneline(X509_get_issuer_name(cert), 0, 0);
        printf("Issuer: %s\n", line);
        free(line);
        X509_free(cert);
    }
    else
        printf("No certificates.\n");
}
  
void Servlet(SSL* ssl) /* Serve the connection -- threadable */
{   char buf[1024];
    char reply[1024];
    int sd, bytes;
    const char* HTMLecho="<html><body><pre>%s</pre></body></html>\n\n";
  
    if ( SSL_accept(ssl) == FAIL )     /* do SSL-protocol accept */
        ERR_print_errors_fp(stderr);
    else
    {
        ShowCerts(ssl);        /* get any certificates */
        bytes = SSL_read(ssl, buf, sizeof(buf)); /* get request */
        if ( bytes > 0 )
        {
            buf[bytes] = 0;
            printf("Client msg: \"%s\"\n", buf);
            sprintf(reply, HTMLecho, buf);   /* construct reply */
            SSL_write(ssl, reply, strlen(reply)); /* send reply */
        }
        else
            ERR_print_errors_fp(stderr);
    }
    sd = SSL_get_fd(ssl);       /* get socket connection */
    SSL_free(ssl);         /* release SSL state */
    close(sd);          /* close connection */
}
  
int main(int count, char *strings[])
{   SSL_CTX *ctx;
    int server;
    char *portnum;
  
    if ( count != 2 )
    {
        printf("Usage: %s <portnum>\n", strings[0]);
        exit(0);
    }
    SSL_library_init();
  
    portnum = strings[1];
    ctx = InitServerCTX();        /* initialize SSL */
    LoadCertificates(ctx, "mycert.pem", "mycert.pem"); /* load certs */
    server = OpenListener(atoi(portnum));    /* create server socket */
    while (1)
    {   struct sockaddr_in addr;
        socklen_t len = sizeof(addr);
        SSL *ssl;
  
        int client = accept(server, (struct sockaddr*)&addr, &len);  /* accept connection as usual */
        printf("Connection: %s:%d\n",inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
        ssl = SSL_new(ctx);              /* get new SSL state with context */
        SSL_set_fd(ssl, client);      /* set connection socket to SSL state */
        Servlet(ssl);         /* service connection */
    }
    close(server);          /* close server socket */
    SSL_CTX_free(ctx);         /* release context */
    return 0;
}

컴파일 :

gcc -Wall -o server server.c -lssl -lcrypto

client

Collapse source

#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <malloc.h>
#include <string.h>
#include <sys/socket.h>
#include <resolv.h>
#include <netdb.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
  
#define FAIL    -1
  
int OpenConnection(const char *hostname, int port)
{   int sd;
    struct hostent *host;
    struct sockaddr_in addr;
  
    if ( (host = gethostbyname(hostname)) == NULL )
    {
        perror(hostname);
        abort();
    }
    sd = socket(PF_INET, SOCK_STREAM, 0);
    bzero(&addr, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr.s_addr = *(long*)(host->h_addr);
    if ( connect(sd, (struct sockaddr*)&addr, sizeof(addr)) != 0 )
    {
        close(sd);
        perror(hostname);
        abort();
    }
    return sd;
}
  
SSL_CTX* InitCTX(void)
{   SSL_METHOD *method;
    SSL_CTX *ctx;
  
    OpenSSL_add_all_algorithms();  /* Load cryptos, et.al. */
    SSL_load_error_strings();   /* Bring in and register error messages */
    method = SSLv23_client_method();  /* Create new client-method instance */
    ctx = SSL_CTX_new(method);   /* Create new context */
    if ( ctx == NULL )
    {
        ERR_print_errors_fp(stderr);
        abort();
    }
    return ctx;
}
  
void ShowCerts(SSL* ssl)
{   X509 *cert;
    char *line;
  
    cert = SSL_get_peer_certificate(ssl); /* get the server's certificate */
    if ( cert != NULL )
    {
        printf("Server certificates:\n");
        line = X509_NAME_oneline(X509_get_subject_name(cert), 0, 0);
        printf("Subject: %s\n", line);
        free(line);       /* free the malloc'ed string */
        line = X509_NAME_oneline(X509_get_issuer_name(cert), 0, 0);
        printf("Issuer: %s\n", line);
        free(line);       /* free the malloc'ed string */
        X509_free(cert);     /* free the malloc'ed certificate copy */
    }
    else
        printf("No certificates.\n");
}
  
int main(int count, char *strings[])
{   SSL_CTX *ctx;
    int server;
    SSL *ssl;
    char buf[1024];
    int bytes;
    char *hostname, *portnum;
  
    if ( count != 3 )
    {
        printf("usage: %s <hostname> <portnum>\n", strings[0]);
        exit(0);
    }
    SSL_library_init();
 hostname=strings[1];
 portnum=strings[2];
  
    ctx = InitCTX();
    server = OpenConnection(hostname, atoi(portnum));
    ssl = SSL_new(ctx);      /* create new SSL connection state */
    SSL_set_fd(ssl, server);    /* attach the socket descriptor */
    if ( SSL_connect(ssl) == FAIL )   /* perform the connection */
        ERR_print_errors_fp(stderr);
    else
    {   char *msg = "Hello???";
  
        printf("Connected with %s encryption\n", SSL_get_cipher(ssl));
        ShowCerts(ssl);        /* get any certs */
        SSL_write(ssl, msg, strlen(msg));   /* encrypt & send message */
        bytes = SSL_read(ssl, buf, sizeof(buf)); /* get reply & decrypt */
        buf[bytes] = 0;
        printf("Received: \"%s\"\n", buf);
        SSL_free(ssl);        /* release connection state */
    }
    close(server);         /* close socket */
    SSL_CTX_free(ctx);        /* release context */
    return 0;
}
 

컴파일 :

gcc -Wall -o server client.c -lssl -lcrypto

references:

[1] Secure programming with the OpenSSL API, Part 1: Overview of the API : http://www.ibm.com/developerworks/library/l-openssl.html

[2] Korean Version of [1] : http://hasu0707.tistory.com/153

[3] Secure Server Client using OpenSSL in C : http://simplestcodings.blogspot.kr/2010/08/secure-server-client-using-openssl-in-c.html

[4] HTTPS와 SSL 인증서 : http://opentutorials.org/course/228/4894

[5] SSL/TLS Programming : http://www.cs.odu.edu/~cs772/fall08/lectures/ssl_programming.pdf

binary heap 구현 시 indexing

바보세룐 — Fri, 28 Nov 2014 17:12:04 +0900

binary heap 구현 시,

root 를 0 으로 하는 것과 1 로 하는 것의 차이를 보자.

* i 의 child

	left child	right child
0-based	i * 2 + 1	(i+1) * 2
1-based	i * 2	i * 2 + 1

* i 의 parent

	i 가 left 일 때	i 가 right 일 때
0-based	i / 2	(i-1) / 2
1-based	i / 2	i / 2

root 의 index 를 1 로 하여 구현하는 것이 계산이 더 간단하다.

뿐만 아니라 다음과 같은 이점이 있다.


depth 0	1
depth 1	2	3
depth 2	4	5	6	7
depth 3	8	9	10	11	12	13	14	15

index 를 2 진수로 변환하면, 같은 depth 인 경우 자리 수가 같아진다.


depth 0	1
depth 1	10	11
depth 2	100	101	110	111
depth 3	1000	1001	1010	1011	1100	1101	1110	1111

또한 가장 왼쪽 node 의 index 는 항상 첫 자리가 1 이고 나머지 자리는 모두 0 이 된다.

가장 마지막 node 의 index 는 항상 모든 자리가 1 이다.

이런 이유로, index 값만으로 depth 를 알 수 있고 그 외 유용한 연산을 더 빠르고 간편하게 해 낼 수 있다.

특별한 이유가 없다면 binary heap 구현은 root index 를 1 로 하는 게 좋다.

최대 구간 합 문제 (maximum subarray problem)

바보세룐 — Thu, 16 Oct 2014 12:36:35 +0900

maximum subarray problem [1]

주어진 배열에서 합이 가장 큰 구간을 찾는 문제이다.

다음은 O(N^3) 방법. 전체를 순서대로 뒤지는 방법이다.

아래는 O(N^2) 방법.

int max_sum() { int input [] = {-2, 1, -3, 4, -1, 2, 1, -5, 4}; size_t size = sizeof(input)/sizeof(int); int i, j, sum; int value = 0xFFFFFFFF; for (i = 0; i < size; i++) { sum = 0; for (j = i; j < size; j++) { sum += input[j]; value = max(value, sum); } } trace("%d\n", value); return value; }

O(nlog n) 방법 : divide and conquer algorithm

int input [] = {-2, 1, -3, 4, -1, 2, 1, -5, 4}; size_t size = sizeof(input)/sizeof(int); trace("%d\n", max_sum(input, 0, size - 1)); int max_sum(int input[], int lo, int hi) { // 하나 뿐일 때 if (lo == hi) return input[lo]; int mid = (lo + hi) / 2; int left = 0xFFFFFFFF, right = 0xFFFFFFFF; int sum = 0; for (int i = mid; i >= lo; i--) { sum += input[i]; left = max(left, sum); } sum = 0; for (int j = mid + 1; j <= hi; j++) { sum += input[j]; right = max(right, sum); } int single = max(max_sum(input, lo, mid), max_sum(input, mid+1, hi)); return max(left + right, single); }

O(n) 방법 : Kadane's algorithm

int max_sum() { int input [] = {-2, 1, -3, 4, -1, 2, 1, -5, 4}; size_t size = sizeof(input)/sizeof(int); int max_so_far = input[0], max_ending_here = input[0]; for (int i = 1; i < size; i++) { if (max_ending_here < 0) { max_ending_here = input[i]; // begin_temp = i; } else { max_ending_here += input[i]; } max_so_far = max(max_ending_here, max_so_far); //if (max_ending_here > max_so_far) { // begin = begin_temp; // end = i; //} } trace("%d\n", max_so_far); return max_so_far; }

references :

[1] http://en.wikipedia.org/wiki/Maximum_subarray_problem

n 개 중 m 개 고르는 조합 (all possible combinations) cpp

바보세룐 — Thu, 19 Jun 2014 21:10:57 +0900

n 개 가운데 m 개를 고르는 모든 조합 ...

첫 번째 방법은 vector 를 이용하여 적절한 index 를 push 하는 방법이다.

일반적인 방법.

두 번째는 n 이 31 이하인 경우 사용가능하다.

bit 연산을 하므로 매우 빠르다.

대략 비교해 보면 후자가 5 ~ 7 배 빠른 것같다. (물론 경우에 따라 다르겠지만)

어차피 n 이 너무 커지면 경우의 수가 너무 많아 계산이 불가능하므로, 후자가 유용하게 사용될 수 있을 듯.

구글링 해 보니 요런 것도 있다.

http://www.geeksforgeeks.org/print-all-possible-combinations-of-r-elements-in-a-given-array-of-size-n/

bit operations & twiddling hacks

바보세룐 — Mon, 16 Jun 2014 14:15:48 +0900

이 페이지는 bit twidding hacks 에 관한 내용으로, 다음 페이지의 내용 중 일부를 해석, 분석, 시험한 내용입니다.

http://graphics.stanford.edu/~seander/bithacks.html

* 참고 :

two's complement

http://en.wikipedia.org/wiki/Two's_complement

Compute the integer absolute value (abs) without branching

int v;           // we want to find the absolute value of v
unsigned int r;  // the result goes here 
int const mask = v >> sizeof(int) * CHAR_BIT - 1;  // CHAR_BIT == 8
 
r = (v + mask) ^ mask;
// or, r = (v ^ mask) - mask;

v 가 양수인 경우 (v = 10)

v : 0x0000000A
mask : 0x0
v + mask : 0x0000000A
(v + mask) ^ mask : 0x0000000A

v 가 음수인 경우 (v = -10)

v : 0xFFFFFFF6
mask : 0xFFFFFFFF
v + mask : 0xFFFFFFF5
(v + mask) ^ mask : 0x0000000A

2's complement 를 구하는 방법과 동일하다.

Compute the minimum (min) or maximum (max) of two integers without branching

Determining if an integer is a power of 2

unsigned int v; // we want to see if v is a power of 2
bool f;         // the result goes here 
 
f = (v & (v - 1)) == 0;

만약 v 가 0010 (2) 이라면,

v : 0010 (2)
v - 1 : 0001 (2)
v & (v - 1) : 0

만약 v 가 0110 (2) 이라면,

v : 0110 (2)
v - 1 : 0101 (2)
v & (v - 1) : 0100

v 가 0 이면 true 가 되는 문제가 있다. (별도 handling 필요)

f = v && !(v & (v - 1));

이 연산은 정수의 가장 오른쪽 1 을 하나 지우는 것과 같다.

그러므로, 비트 가운데 1 이 하나만 있는 경우 (power of 2) 가장 오른쪽 비트를 지우면 0 이 된다.

따라서, 음수에는 안 된다. (예문은 검사할 변수가 unsigned 로 되어 있음)

Conditionally set or clear bits without branching

bool f;         // conditional flag
unsigned int m; // the bit mask
unsigned int w; // the word to modify:  if (f) w |= m; else w &= ~m; 
 
w ^= (-f ^ w) & m;

조건 f 에 따라서 w 의 특정 비트 (m) 를 set 하거나 clear 하기

여기서는 f 값이 true 인 경우 set, false 일 때 clear 한다.

// f : 1 (true)
// m : 0011 (2)
// w : 0000 (2)
// ------------
// -f : 1111
// -f ^ w : 1111
// (-f ^ w) & m : 0011
 
// w ^ (-f ^ w) & m : 0011

// f : 1 (true)
// m : 0111 (2)
// w : 0010 (2)
// ------------
// -f : 1111
// -f ^ w : 1101
// (-f ^ w) & m : 0101
 
// w ^ (-f ^ w) & m : 0111

f 는 1 이고 -f 는 1111 이 된다.

여기에 (-f ^ w) 를 계산하면 w 의 모든 비트를 뒤집니다.

그 결과에 & m 을 계산하면, set 하려는 비트 중에 0인 비트에만 1 이 할당 된다.

따라서, 그 결과에 w 와 XOR 를 씌우면, 기존에 이미 set 된 비트는 그대로 1 로 남고, 0 이었던 비트도 1 로 set 된다.

Counting bits set (naive way)

unsigned int v; // count the number of bits set in v
unsigned int c; // c accumulates the total bits set in v
 
for (c = 0; v; v >>= 1)
{
  c += v & 1;
}

Counting bits set, Brian Kernighan's way

unsigned int v; // count the number of bits set in v
unsigned int c; // c accumulates the total bits set in v
for (c = 0; v; c++)
{
  v &= v - 1; // clear the least significant bit set
}

루프 한 번 마다 v & v - 1 을 하면 가장 오른쪽 비트(least significant bit)를 지운다.

gcc 에서는 내장 함수 __builtin_popcount() 를 사용하면 된다.

visual studio 2008 에서는 _mm_popcnt_u32(), _mm_popcnt_u64() 이런 게 있다. <nmmintrin.h> 필요.

참고 : http://msdn.microsoft.com/en-us/library/bb514083(v=vs.90).aspx

Select the bit position (from the most-significant bit) with the given count (rank)

The following 64-bit code selects the position of the r^th 1 bit when counting from the left. In other words if we start at the most significant bit and proceed to the right, counting the number of bits set to 1 until we reach the desired rank, r, then the position where we stop is returned. If the rank requested exceeds the count of bits set, then 64 is returned. The code may be modified for 32-bit or counting from the right.

uint64_t v;          // Input value to find position with rank r.
  unsigned int r;      // Input: bit's desired rank [1-64].
  unsigned int s;      // Output: Resulting position of bit with rank r [1-64]
  uint64_t a, b, c, d; // Intermediate temporaries for bit count.
  unsigned int t;      // Bit count temporary.
 
  // Do a normal parallel bit count for a 64-bit integer,                     
  // but store all intermediate steps.                                        
  // a = (v & 0x5555...) + ((v >> 1) & 0x5555...);
  a =  v - ((v >> 1) & ~0UL/3);
  // b = (a & 0x3333...) + ((a >> 2) & 0x3333...);
  b = (a & ~0UL/5) + ((a >> 2) & ~0UL/5);
  // c = (b & 0x0f0f...) + ((b >> 4) & 0x0f0f...);
  c = (b + (b >> 4)) & ~0UL/0x11;
  // d = (c & 0x00ff...) + ((c >> 8) & 0x00ff...);
  d = (c + (c >> 8)) & ~0UL/0x101;
  t = (d >> 32) + (d >> 48);
  // Now do branchless select!                                                
  s  = 64;
  // if (r > t) {s -= 32; r -= t;}
  s -= ((t - r) & 256) >> 3; r -= (t & ((t - r) >> 8));
  t  = (d >> (s - 16)) & 0xff;
  // if (r > t) {s -= 16; r -= t;}
  s -= ((t - r) & 256) >> 4; r -= (t & ((t - r) >> 8));
  t  = (c >> (s - 8)) & 0xf;
  // if (r > t) {s -= 8; r -= t;}
  s -= ((t - r) & 256) >> 5; r -= (t & ((t - r) >> 8));
  t  = (b >> (s - 4)) & 0x7;
  // if (r > t) {s -= 4; r -= t;}
  s -= ((t - r) & 256) >> 6; r -= (t & ((t - r) >> 8));
  t  = (a >> (s - 2)) & 0x3;
  // if (r > t) {s -= 2; r -= t;}
  s -= ((t - r) & 256) >> 7; r -= (t & ((t - r) >> 8));
  t  = (v >> (s - 1)) & 0x1;
  // if (r > t) s--;
  s -= ((t - r) & 256) >> 8;
  s = 65 - s;

Swapping values with XOR

#define SWAP(a, b) (((a) ^= (b)), ((b) ^= (a)), ((a) ^= (b)))
 
// 즉, 이렇게 XOR 세 번 하면 바뀐다.
a ^= b;
b ^= a;
a ^= b;

Swapping individual bits with XOR

unsigned int i, j; // positions of bit sequences to swap
unsigned int n;    // number of consecutive bits in each sequence
unsigned int b;    // bits to swap reside in b
unsigned int r;    // bit-swapped result goes here
 
unsigned int x = ((b >> i) ^ (b >> j)) & ((1U << n) - 1); // XOR temporary
r = b ^ ((x << i) | (x << j));

Compute modulus division by 1 << s without a division operator

const unsigned int n;          // numerator
const unsigned int s;
const unsigned int d = 1U << s; // So d will be one of: 1, 2, 4, 8, 16, 32, ...
unsigned int m;                // m will be n % d
m = n & (d - 1);

d - 1 은 d 번째 부터 0111 이 된다.

즉 d 가 1000 이었다면 d - 1 은 0111 이다.

따라서 n 과 & 연산을 하면 하위 3 자리만 남는다.

Find the log base 2 of an integer with the MSB N set in O(N) operations (the obvious way)

unsigned int v; // 32-bit word to find the log base 2 of
unsigned int r = 0; // r will be lg(v)
 
while (v >>= 1) // unroll for more speed...
{
  r++;
}

v 를 한 칸씩 shift 하면서 r 을 증가 시킴.

Find the integer log base 2 of an integer with an 64-bit IEEE float

int v; // 32-bit integer to find the log base 2 of
int r; // result of log_2(v) goes here
union { unsigned int u[2]; double d; } t; // temp
 
t.u[__FLOAT_WORD_ORDER==LITTLE_ENDIAN] = 0x43300000;
t.u[__FLOAT_WORD_ORDER!=LITTLE_ENDIAN] = v;
t.d -= 4503599627370496.0; // 2 ^ 52
r = (t.u[__FLOAT_WORD_ORDER==LITTLE_ENDIAN] >> 20) - 0x3FF;

The code above loads a 64-bit (IEEE-754 floating-point) double with a 32-bit integer (with no paddding bits) by storing the integer in the mantissa while the exponent is set to 2⁵². From this newly minted double, 2⁵² (expressed as a double) is subtracted, which sets the resulting exponent to the log base 2 of the input value, v. All that is left is shifting the exponent bits into position (20 bits right) and subtracting the bias, 0x3FF (which is 1023 decimal). This technique only takes 5 operations, but many CPUs are slow at manipulating doubles, and the endianess of the architecture must be accommodated.

Eric Cole sent me this on January 15, 2006. Evan Felix pointed out a typo on April 4, 2006. Vincent Lefèvre told me on July 9, 2008 to change the endian check to use the float's endian, which could differ from the integer's endian.

이해 불가 ㅡㅡ;

Count the consecutive zero bits (trailing) on the right linearly

unsigned int v;  // input to count trailing zero bits
int c;  // output: c will count v's trailing zero bits,
        // so if v is 1101000 (base 2), then c will be 3
if (v)
{
  v = (v ^ (v - 1)) >> 1;  // Set v's trailing 0s to 1s and zero rest
  for (c = 0; v; c++)
  {
    v >>= 1;
  }
}
else // 0 인 경우
{
  c = CHAR_BIT * sizeof(v);
}

v ^ v - 1 을 하면 가장 가장 오른쪽 비트 (lsb) 자리부터 1이 채워지고, 한 번 shift 하면 1 이 하나 지워진다.

// v : 1100
// v - 1 : 1011
// v ^ v - 1 : 111

이 결과에서 shift 를 한 번 하면 11 만 남는다.

for 문은 1 의 개수를 센다.

gcc 라면 __builtin_ctz() 함수를 사용할 수 있다.

visual studio 에서는 _BitScanForward() 가 있다.

참고 : http://msdn.microsoft.com/en-us/library/wfd9z0bb%28VS.80%29.aspx

반대 방향으로 0 의 개수를 세는 함수는,

gcc 와 visual studio 에 대해서 각각 __builtin_clz(), _BitScanReverse() 가 있음.

Compute the lexicographically next bit permutation

Suppose we have a pattern of N bits set to 1 in an integer and we want the next permutation of N 1 bits in a lexicographical sense. For example, if N is 3 and the bit pattern is 00010011, the next patterns would be 00010101, 00010110, 00011001,00011010, 00011100, 00100011, and so forth. The following is a fast way to compute the next permutation.

unsigned int v; // current permutation of bits 
unsigned int w; // next permutation of bits
 
unsigned int t = v | (v - 1); // t gets v's least significant 0 bits set to 1
// Next set to 1 the most significant bit to change, 
// set to 0 the least significant ones, and add the necessary 1 bits.
w = (t + 1) | (((~t & -~t) - 1) >> (__builtin_ctz(v) + 1));

또는,

unsigned int t = (v | (v - 1)) + 1;  
w = t | ((((t & -t) / (v & -v)) >> 1) - 1);

복잡하군요 @.@

테스트 코드 :

#include <iostream>
 
using namespace std;
typedef unsigned int uint32;
 
void print(uint32 a) {
    for (int i = 31; i >= 0; i--) {
        int flag = a & (1 << i) ;
        if (flag) cout << 1;
        else cout << 0;
        if ((i) % 4 == 0) cout << " ";
    }
    cout << ": (" << a << ")" << endl;
}
uint32 next(uint32 v) {
    unsigned int w; // next permutation of bits
    unsigned int t = v | (v - 1); // t gets v's least significant 0 bits set to 1
    // Next set to 1 the most significant bit to change,
    // set to 0 the least significant ones, and add the necessary 1 bits.
    w = (t + 1) | (((~t & -~t) - 1) >> (__builtin_ctz(v) + 1));
    return w;
}
int main() {
    uint32 a = 3;
    print(a);
    for (int i = 0; i < 500; i++) {
        a = next(a);
        print(a);
    }
    return 0;
}

만약, 최고 값까지 다다른 다음에 한 번 더 호출하면 1 의 개수가 하나 줄어든 값이 튀어 나온다. (주의 !)