조합/중복조합 [파이썬]

역시 파이썬이 더 재미있다.

def factorial(n):
  if n <= 1:
    return 1
  else:
    result = 1
    for i in range(2, n+1):
      result *= i
    return result

# nCk = n! / (n-k)! * k!
def comb_slow(n, k):
  return factorial(n) / (factorial(k)*factorial(n-k))
  
print(comb_slow(6,3))

def comb_fast(n, k):
  numerator = 1
  denominator = 1
  k = min(n-k, k)  # nCk에서 더 적은 수로 계산하기 위해서.
  den_list = []
  num_list = []
  for i in range(k):  # 기존 소스에서 이곳을 변경함.
    denominator *= i + 1
    numerator *= n-i
    den_list.append(i+1)
    num_list.append(n-i)
  print('den_list={}'.format('*'.join(str(x) for x in den_list)))
  print('num_list={}'.format('*'.join(str(x) for x in num_list)))
  
  return numerator/denominator
  
print(comb_fast(6,3))

# 번외 중복조합
# nHr = n+r-1Cr
def ham(n, k):
  return comb_fast(n+k-1, k)
  
print(ham(6, 3))

# 참고문헌 : https://smlee729.github.io/python/algorithm/2015/03/08/1-nchoosek.html

최대 이익 투자 [C언어]

출처 : 문제로 풀어보는 알고리즘

#include 
/*
최대이익투자 : 문제로 풀어보는 알고리즘

4 3  투자금액, 투자 가능 기업의 수
2 3 1  기업별 1만원 투자시 이익
4 5 3  기업별 2만원
7 6 7  기업별 3만원
9 8 9  기업별 4만원

return 10 : 최대이익.
4 3
2 3 1
4 5 3
7 6 7
9 8 9
*/

#define M 100
#define N 100

int r[M][N];
int max_return[M][N];

void calculate_return(int n, int m)
{
  int i, j, k, max, t;

  // dynamic programming을 위해 미리 첫번재 기업을 세팅을 한다. (처음이니까 무조건 max)  
  for (i = 0; i <= m; i++)  {
    // 맨 윗줄.
    max_return[0][i] = r[0][i];
  }
  
  for (i = 0; i < n; i++) {
    for (j = 0; j < m+1; j++) {
      printf("%d ", r[i][j]);
    }
    printf("\n");
    
  }
  
  
  // 두번째줄부터 시작함.
  for (i = 1; i < n; i++)  // i는 기업.
    for (j = 1; j < m+1; j++) {  
    // j는 총 투자할 양 m+1인 이유는 m=0인 경우(투자안한경우)도 다뤄야 하기 때문.
    // 기업의 수(i) 투자할 양(j)를 작은 수로 시작해서 기록-> 큰 수로 간다.
      max = -1;
      for (k = 0; k <= j; k++) {  
// 이전에 투자한 회사와 액수에 대한 내용을 바탕으로 더한다.
// t = 이전 회사에 k를 투자한양과 지금 회사에 j에서 k만큼 이전회사에 투자한 양을 뺀 경우.
// 왜 계속 이전회사만하고만 비교를 하냐면 동적프로그래밍으로 계속 그 최대값이 각 배열마다 누적될 것이다. 
// 그러니 이전 내용과는 비교할 이유가 없다.
        t = max_return[i-1][k] + r[i][j - k];  // 무조건 왼쪽 + 위쪽인데.
        //printf("i=%d, j=%d, k=%d t: %d\n", i,j,k,t);
        if (t > max)
          max = t;
      }
      max_return[i][j] = max;
    }
    

}

int main(void) {
  int m, n, i, j;
  
  scanf("%d %d", &n, &m);
  for (i = 0; i < n; i++)
    r[i][0] = 0;

  for (i = 1; i <= m; i++)
    for (j = 0; j < n; j++)
      scanf("%d", &r[j][i]); // 정보를 받아온다.
      
  calculate_return(n, m);
  printf("Max return: %d\n", max_return[n-1][m]);
  return 0;
}

무게가 있는 길찾기 [C 언어]

#include 

#define M 100
#define N 100

int map[M][N];

int max(int x, int y)
{
  if (x > y)
    return x;
  return y;
}

int max_joy(int m, int n)
{
  if (m == 0 && n == 0) {
    return map[0][0];
  }
  // 맨 위인경우.
  if (m == 0) {
    return max_joy(m, n-1) + map[m][n];
  }
  // 맨 왼쪽인경우.
  if (n == 0) {
    return max_joy(m-1, n) + map[m][n];
  }
  // 위,왼 중에 max를 골라서 더함.
  return max(max_joy(m-1, n), max_joy(m, n-1)) + map[m][n];
}

int joy[M][N];
void dynamic_joy(int m, int n)
{
  int i, j;
  
  joy[0][0] = map[0][0]; // 0,0 처음세팅.
  // 맨위,맨왼 세팅
  for (i = 1; i < m; ++i) {
    joy[i][0] = joy[i-1][0] + map[i][0];
  }
  for (j = 1; j < n; ++j) {
    joy[0][j] = joy[0][j-1] + map[0][j];
  }
  
  // 그 사이들 세팅.
  for (i = 1; i < m; ++i)
    for (j = 1; j < n; ++j)
      joy[i][j] = max(joy[i-1][j], joy[i][j-1]) + map[i][j];
}

/*
5 5
1 2 2 1 5
1 4 4 3 1
2 1 1 1 2
1 3 5 1 1
1 5 1 2 2
*/
int main() {
  int m, n, i, j;
  
  scanf("%d %d", &m, &n);
  for (i = 0; i < m; i++)
    for (j = 0; j < n; j++)
      scanf("%d", &map[i][j]);
  printf("%d\n", max_joy(m-1, n-1));
  
  dynamic_joy(m, n);
  
  for (i = 0; i < m; i++) {
    for (j = 0; j < n; j++)
      printf("%d ", joy[i][j]);
    printf("\n");
  }
  return 0;
}

동적프로그래밍 길찾기 [C 언어]

#include 

#define M 100
#define N 100

int map[M][N];

long long num_path(int m, int n)
{
  // 장애물이면 0
  if (map[m][n] == 0) {
    return 0;
  }
  // m=i,n=j에서 0,0으로 갔으면 +1
  if (m == 0 && n == 0) {
    return 1;
  }
  
  return ((m > 0) ? num_path(m - 1, n) : 0)
    + ((n > 0) ? num_path(m, n - 1) : 0);
}

// 와... 값을 리턴하는 것이 아닌 map에 값을 넣는다.
long long path[M][N];
void dynamic_programming_path(int m, int n)
{
  int i, j;  // 이중포문용
  path[0][0] = map[0][0];
  
  
  // 1. 세로 맨 왼쪽은 왼쪽을 더할필요가 없음.
  for(i = 1; i < m; ++i) { //i=0 : path[-1][0]이 없기 때문에 스킵
    if (map[i][0] == 0) {
      path[i][0] = 0;
    } else {
      path[i][0] = path[i-1][0];  // 2. 여기 path[i][0-1]
    }
  }
  // 2. 가로 맨 왼쪽은 위쪽을 더할 필요가 없음.
  for(j = 1; j < n; ++j) { // j=0 은 path[0][-1]가 없기 때문에 스킵
    if (map[0][j] == 0) {
      path[0][j] = 0;
    } else {
      path[0][j] = path[0][j-1]; // 2. 여기 path[0-1][j]
    }
  }

  for (i = 1; i < m; i++) {
    for (j = 1; j < n; j++) {
      if (map[i][j] == 0) {
        path[i][j] = 0;
      } else {
        // 동적프로그래밍 한칸 한칸 나아간다.
        path[i][j] = path[i-1][j] + path[i][j-1];
      }
    }
  }
}


/*
5 5
1 1 1 1 1
1 1 0 0 1
1 1 1 1 1
1 1 1 0 1
0 0 1 1 1
*/
int main(void) {
  int m, n, i, j;

  scanf("%d %d", &m, &n);
  for (i = 0; i < m; i++) {
    for (j = 0; j < n; j++) {
      scanf("%d", &map[i][j]);
    }
  }
  // 반대로 가는듯.
  // printf("%lld\n", num_path(m-1, n-1));
  dynamic_programming_path(m, n);

  return 0;
}

출처: 문제로 풀어보는 알고리즘

수 분할 [C 언어]

#include 
// 수분할

// partition(0, m) =1 
// partition(n,m) = i~m partition(n-i,i)
int partition(int n, int m)
{
  int count = 0, i;
  
  // n/m 수분할은 n/n 수문할과 같으므로 m에 n을 대입한다.
  // 5를 6까지 이용해서 분할할 수는 없으니까
  if (n < m) {
    // printf("n=%d, m=%d\n", n, m);
    m = n;
  }
  if (n == 0) // Base Case 0
    return 1;

  for (i = 1; i <= m; i++) {
    // printf("call partition(%d, %d);\n", n-i, i);
    count += partition(n - i, i);
  }
  return count;
}

#define MAX 1000
int partition_cache(int n, int m)
{
  static int cache[MAX][MAX];
  int count = 0, i;
  
  if (n < m) {
    m = n;
  }
  if (cache[n][m]) {
    return cache[n][m];
  }
  if (n == 0) {
    return cache[n][m] = 1;
  }
  
  for (i = 1; i <= m; i++) {
    count += partition_cache(n - i, i);
  }
  
  return cache[n][m] = count;
}

int main(void) {
  // printf("first %d\n", partition(1000,4));
  printf("second %d\n",  partition_cache(1000, 4));
  return 0;
}

금액계산 경우의 수 [C 언어]

#include 
// 금액 맞추기
// 브루트포스 / 재귀
// 일정금액을 1,2,5,10,20,50 만원으로 계산 가능 가짓수.


void brute(int* bills, int money) {
  int i0, i1, i2, i3, i4; // 각 계산 후 남은 수.
  int count = 0;
  for (i0 = money; i0 >= 0; i0 -=bills[0])
    for (i1 = i0; i1 >= 0; i1 -= bills[1])
      for (i2 = i1; i2 >= 0; i2 -= bills[2])
        for (i3 = i2; i3 >= 0; i3 -= bills[3])
          for (i4 = i3; i4 >= 0; i4 -= bills[4])
            if (i4 % bills[5] == 0)
              count++;
              
  printf("count = %d\n", count);
}

int better(int* bills, int n, int money)
{
  int count = 0, i;
  
  if (n == 1) {
    if (money % bills[0] == 0)
      return 1;
    else
      return 0;
  }

  int len = money / bills[n-1];
  for (i = 0; i <= len; i++) {
    count += better(bills, n-1, money - (bills[n-1] * i));
  }
  
  return count;
}

int main(void) {
  int bills[6] = {1,2,5,10,20,50};
  int money = 100; // res = 4562
  int numberOfBills = 6;
  
  brute(bills, money); 
  // printf("better way : %d\n", better(bills, numberOfBills, money));
  
  return 0;
}

[fibonacci] 피보나치 [C 언어]

피보나치 지긋지긋하다.

#include 
#include 
// 피보나치 수열

long long fibo(int n)
{
  if (n == 1 || n == 2) {
    return 1;
  }
  
  return fibo(n-1) + fibo(n-2);
}

// cache
#define MAXSIZE 100
long long fibo2(int n) {
  static long long cache[MAXSIZE];
  
  if (cache[n])
    return cache[n];
    
  if (n == 1 || n == 2)
    // cache[n] = 1;
    return cache[n] = 1;
    
  // cache[n] = fibo2(n-1) + fibo2(n-2);
  return cache[n] = fibo2(n-1) + fibo2(n-2);
}

// 재귀 없이 풀기
long long fibo3(int n) {
  int i;
  long long f_res, f_a, f_b;
  
  if (n == 1 || n == 2)
    return 1;

  // f(3) = f(2) + f(1);
  // f(n) = f(n-1) + f(n-2)
  f_a = 1;
  f_b = 1;
  for (i = 3; i <= n; ++i) {
    f_res = f_a + f_b;
    f_a = f_b;
    f_b = f_res;
  }
  
  return f_res;
}


int main(void) {
  printf("Hello World\n");
  // printf("%lld\n", fibo(100)); 
  printf("%lld\n", fibo2(100));
  printf("%lld\n", fibo3(100)); 
  return 0;
}

[binomial_coefficient] 이항계수 [C 언어]

// 이항계수
#include 

// nCr = n-1Cr-1 + n-1Cr
long long binomial_coefficient(int n, int r)
{
  if (r == 0 || r == n)
    return 1;
    
  return binomial_coefficient(n-1, r-1) + binomial_coefficient(n-1, r);
}

#define MAX_SIZE 100
// cache
long long binomial_coefficient2(int n, int r)
{
  static long long cache[MAX_SIZE][MAX_SIZE] = { 0, };
  
  if (cache[n][r]) {
    return cache[n][r];
  }
  
  if (r == 0 || r == n)
    return 1;
    
  cache[n][r] = binomial_coefficient2(n-1, r-1) + binomial_coefficient2(n-1, r);
  return cache[n][r];
}
int main(void) {
  printf("Hello World\n");
  //printf("%lld\n", binomial_coefficient(100,52)); // 5C2
  printf("%lld\n", binomial_coefficient2(100,52)); // 5C2
  return 0;
}

factorial 두가지 방법 [C 언어]

#include 

int factorial(int n)
{
  int res, i;
  
  res = 1;
  for(i = 2; i <= n; i++) {
    res *= i;
  }
  return res;
}

int factorial2(int n)
{
  if (n == 1)
    return 1;
    
  return n * factorial2(n - 1);
}

int main(void) {
  printf("Hello World\n");
  printf("%d\n", factorial(5));
  printf("%d\n", factorial2(5));
  return 0;
}

[책리뷰] C++를 대하는 한 남자의 철학적 사견 [이것이 C++다]

C++에 대해서 나는 잘 모르지만 교보문고에 항상 이 책이 진열되어 있는 것을 보아왔다.
Java개발을 하기에 C++에 대해서 잘 모르지만,
가끔 간단하게 C언어로 된 언어를 봐야 한다거나,
C++로 된 내용을 볼 때 조금이나마 도움이 될까 해서 읽게 되었다.

모든 언어가 그렇듯이 한권의 책을 읽고 그 언어를 이해할 수는 없을 것이다.
모든 언어를 익힐 때 그렇듯이 결국 도큐먼트를 읽고 레퍼런스를 읽어야 할 것이다.

그렇다면 왜 우리는 왜 이런 책을 읽어야 하는가
바로 먼저 개발을 시작한 선배 개발자의 사견이 들어가 있기 때문이다.
또한 그들의 통찰력을 얻을 수 있기 때문일 것이다.

저자는 제목부터 그런것들을 보여줄 것임을 공표한다. [이것이 C++이다]는 C++에 대한 깔끔한 레퍼런스를 제공한다는 것보다는
"이것이 내가 생각하는 C++이며, 나의 세상이다." 라는 느낌으로 이해하는 것이 더 옳다.

그러므로 저자는 C++을 가르치기보다 C++을 이용하여 자신이 생각하는 "C++을 이용한 개발"에 초점을 둔다.

그러므로 언어보다는 개발을 문서보다는 철학을 말한다.
인터넷에 검색을 해보면 저자의 강의도 어렵지 않게 구할 수 있다.
그곳에는 책에서는 못다한 저자의 사견을 마저 들을 수 있다.

짜임새가 있는 책인지는 잘 모르겠다. 하지만 일관적이다.
이 책을 다 읽지는 않았다. 아마 C++을 업무에서 주로 쓰게 된다면 다시 읽을 일은 없을 것이다.
다른 언어로 개발을 해도 이 책은 초중반부는 아주 중요한 것을 느끼게 해준다.

진지하게 읽어주기 바란다.
이 책은 깔끔하고 간결하게 쓴 책이 아니다.
오히려 이말 저말이 뒤섞여 있고 같은 말을 반복하는 세상 풍파를 겪은 어르신의 말처럼 어지럽다.
하지만 철학이 담겨 있고, 마음이 담겨 있다.

아마 저자는 이 책을 쓰면서 때로 가슴 속에 무언가가 울컥하기도 하였을 것이다.
C++을 처음 시작하는 분에게는 추천하지 않는다. (나처럼...)
하지만 언젠가는 읽어야 할 것이다.

[python] property 알기

# property

class Square(object):
  def __init__(self, side):
    self.side = side
  def aget(self):
    return self.side ** 2
  def aset(self, value):
    print('no')
  def adel(self, value):
    print('no')
  area = property(aget, aset, adel, doc='area') # 이게 중요!!
  
s = Square(5)
print(s.area)

"""Properties with decorators.
데코레이터를 사용하게 된다. 위에 내용과 같다.
"""

from __future__ import print_function

class Square(object):
    """A square using properties with decorators.
    """
    def __init__(self, side):
        self.side = side
    @property
    def area(self):
        """Calculate the area of the square when the
        attribute is accessed."""
        return self.side * self.side
    @area.setter
    def area(self, value):
        """Don't allow setting."""
        print("Can't set the area")
    @area.deleter
    def area(self):
        """Don't allow deleting."""
        print("Can't delete the area.")

if __name__ == '__main__':

    square = Square(5)
    print('area:', square.area)
    print('try to set')
    square.area = 10
    print('area:', square.area)
    print('try to delete')
    del square.area
    print('area:', square.area)

[python] 스레드 상속하기(subclass)

import time
import threading

class MyThread(threading.Thread):
  def __init__(self, number, style, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.number = number
    self.style = style

  def run(self, *args, **kwargs):
    print('thread starting')
    super().run(*args, **kwargs)
    print('thread has ended')

  def sleeper(num, style):
    print('sleeping for {} {}'.format(num, style))
    time.sleep(num)


t = MyThread(number=3, style='yellow', target=sleeper, args=[3, 'yellow'])
t.start()

[python] 난수 생성하기

출처 : https://stackoverflow.com/questions/2257441/random-string-generation-with-upper-case-letters-and-digits-in-python

파이썬에서 난수를 생성할때 알파벳과 숫자를 더해서 만들 수 있겠다.


파이썬의
''.join(secrets.choice(string.ascii_uppercase + string.digits) for _ in range(N))

random_numbers = set()
for _ in range(240):
    res = ''.join(random.choices(string.ascii_uppercase + string.digits, k=10))
    random_numbers.add(res)

with open('random_number.txt', 'w', newline='\n') as f:
    [f.write(num+'\n') for num in random_numbers]
print(len(random_numbers))

하지만 이건 좀 안전하지 않다.

res = ''.join(random.SystemRandom()
                    .choice(string.ascii_uppercase + string.digits) for _ in range(10))

이렇게 사용하는게 좋겠다.

[largorithm][mergesort] 머지소트 (C / Python)

C Language

main.c

#include 
#include 
#include "mergesort.h"

void printArray(int value[], int count);

int main()
{
    int values[] = { 80, 75, 10, 60, 15, 49, 12, 25 };
    int count = sizeof(values)/sizeof(int);

    mergesort(values, count);
    printArray(values, count);
    return 0;
}


void printArray(int value[], int count)
{
    int i = 0;
    for(i = 0; i < count; i++) {
        printf("%d ", value[i]);
    }
    printf("\n");
}

mergesort.h

#ifndef MERGESORT_H_INCLUDED
#define MERGESORT_H_INCLUDED

void mergesort(int* arr, int count);

#endif // MERGESORT_H_INCLUDED

mergesort_impl.c

#include 
#include 

#include "mergesort.h"

void _mergesort(int* arr, int* pBuffer, int start, int end);
void _mergesort_division(int* arr, int* pBuffer, int start, int middle, int end);

void mergesort(int* arr, int count)
{
    int* pBuffer = (int*)malloc(sizeof(int) * count);
    if(pBuffer != NULL)
    {
        _mergesort(arr, pBuffer, 0, 7);

        free(pBuffer);
    }
}

void _mergesort(int* arr, int* pBuffer, int start, int end)
{
    int middle = 0;
    if (start < end)
    {
        middle = (start + end) / 2;
        _mergesort(arr, pBuffer, start, middle);
        _mergesort(arr, pBuffer, middle+1, end);
        _mergesort_division(arr, pBuffer, start, middle, end);
    }
}

void _mergesort_division(int* arr, int* pBuffer, int start, int middle, int end)
{
    int i = 0, j = 0, k = 0, t = 0;
    i = start;
    j = middle + 1;
    k = start;

    while(i <= middle && j <= end)
    {
        if(arr[i] <= arr[j])
        {
            pBuffer[k] = arr[i];
            i++;
        }
        else
        {
            pBuffer[k] = arr[j];
            j++;
        }
        k++;
    }

    if(i <= middle)
    {
        for(t = i; t <= middle; t++, k++)
        {
           pBuffer[k] = arr[t];
        }
    }
    else
    {
        for(t = j; t <= end; t++, k++)
        {
            pBuffer[k] = arr[t];
        }
    }

    for (t = start; t <= end; t++)
    {
        arr[t] = pBuffer[t];
    }
}

Python

def merge_sort(arr):
    print('split', arr)
    if len(arr) > 1:
        mid = len(arr) // 2
        left = arr[:mid]
        right = arr[mid:]
        
        merge_sort(left)
        merge_sort(right)

        i, j, k = 0, 0, 0

        while i < len(left) and j < len(right):
            if left[i] < right[j]:
                arr[k] = left[i]
                i += 1
            else:
                arr[k] = right[j]
                j += 1
            k += 1

        while i < len(left):
            arr[k] = left[i]
            i += 1
            k += 1

        while j < len(right):
            arr[k] = right[j]
            j += 1
            k += 1
    print('merge', a)
a = [80, 75, 10, 60, 15, 49, 12, 25]
merge_sort(a)
print(a)

[quicksort] 퀵소트 (quicksort with C / Python)

C-language

main.c

#include 
#include 
#include 

#include "selection_sort.h"
#include "quicksort.h"

void printArray(int value[], int count);

int main()
{
    int values[] = { 80, 75, 10, 60, 15, 49, 12, 25 };
    int count = sizeof(values)/sizeof(int);


    printf("quicksort\n");
    // selection_sort(values, count);
    quicksort(values, count);
    printArray(values, count);
    return 0;
}


void printArray(int value[], int count)
{
    int i = 0;
    for(i = 0; i < count; i++) {
        printf("%d ", value[i]);
    }
    printf("\n");
}

quicksort.h

#ifndef QUICKSORT_H_INCLUDED
#define QUICKSORT_H_INCLUDED

void quicksort(int* value, int count);
void _quicksort(int* value, int start, int end);
int quicksort_division(int* value, int left, int right);
void swap(int* left, int* right);
#endif // QUICKSORT_H_INCLUDED

quicksort.c

#include 
#include "quicksort.h"

void quicksort(int* value, int count)
{
    _quicksort(value, 0, count -1);
}

void _quicksort(int* value, int start, int end)
{
    int pivot = 0;

    if (start < end) {
        pivot = quicksort_division(value, start, end);
        _quicksort(value, start, pivot - 1);
        _quicksort(value, pivot+1, end);
    }
}

int quicksort_division(int* value, int left, int right)
{
    int pivot = left;

    while(left = value[pivot]) && (left < right))
            right--;

        if(left < right)
        {
            swap(&value[left], &value[right]);
        }
    }

    swap(&value[pivot], &value[right]);

    return left;
}
void swap(int* left, int* right)
{
    int temp = *left;
    *left = *right;
    *right = temp;
}

Python

def quicksort(arr):
    _quicksort(arr, 0, len(arr)-1)

def _quicksort(arr, start, end):
    if start < end:
        pivot = _quicksort_division(arr, start, end)
        _quicksort(arr, start, pivot-1)
        _quicksort(arr, pivot+1, end)

def _quicksort_division(arr, left, right):
    pivot = left
    while left < right:
        while arr[left] < arr[pivot] and left < right:
            left += 1
        while arr[right] >= arr[pivot] and left < right:
            right -= 1

        if left < right:
            arr[left], arr[right] = arr[right], arr[left]

    arr[left], arr[pivot] = arr[pivot], arr[left]

    return left

a = [80, 75, 10, 60, 15, 49, 12, 25]

quicksort(a)

[python][hackerrank] Append and Delete

link : https://www.hackerrank.com/challenges/append-and-delete/problem

#!/bin/python3
from itertools import zip_longest

s = input().strip()
t = input().strip()
k = int(input().strip())
output = 0

for idx, (i,j) in enumerate(zip_longest(s, t)):
    if i is None or j is None or i != j:
        output = len(s[idx:] + t[idx:])
        break

if k >= len(s+t):
    print('Yes')
elif k >= output and (k - output) & 1 == 0:
    print('Yes')
else:
    print('No')

[python][hackerrank] Find Digits (3 ways)

input1 = '1012'

number = int(input1)
n = len(input1)
res = 0
for i in range(n):
    _in = int(input1[i])
    if (_in != 0 and number % _in == 0):
        res += 1
       
print(res)

input2 ='1012'
number2 = int(input2)
a = (int(x) for x in input1)
res2 = 0
for i in a:
    if i != 0 and (number2 % i) == 0:
        res2 += 1
print(res2)

input3 = '1012'
number3 = int(input3)
# int_generator = (int(x) for x in input1)
res3 = sum( 1 for y in (int(x) for x in input1)
                    if y != 0 and number3 % y == 0)

print(res3)

[javascript] ie 버전체크

var ie = (function(){
           if (window.ActiveXObject === undefined) return null;
           if (!document.querySelector) return 7;
           if (!document.addEventListener) return 8;
           if (!window.atob) return 9;
           if (!document.__proto__) return 10;
           return 11;
  })(); //ie버전체크

[emacs] emacs 한글 세팅 및 시작위치 변경

(cd "d:/clojureworks/")
(set-language-environment "Korean")
(prefer-coding-system 'utf-8)