씅의 기록하는 개발노트

#include <iostream>

#include <algorithm>

using namespace std;

int N, R;

void sol()

{

ios_base::sync_with_stdio(0);

cin.tie(0);

while (true) 

{

long long ret = 1;

cin >> N >> R;

if (N == 0 && R == 0)

break;

//이항계수의 성질

R = min(R, N - R);

for (int i = 1; i <= R; i++) {

ret *= N;

ret /= i;

N--;

}

cout << ret << endl;

}

}

int main()

{

sol();

return 0;

}

#include "pch.h"

#include <iostream>

using namespace std;

/*

1 1 1 1 모

1 1 1 0 도

1 1 0 0 개

1 0 0 0 걸

0 0 0 0 윷

*/

char RET[5] = { 'D', 'C', 'B', 'A', 'E' };

void sol()

{

for (int i = 0; i < 3; i++) {

int idx = 0;

for (int j = 0; j < 4; j++) {

bool tmp;

cin >> tmp;

idx += tmp;

}

cout << RET[idx] << endl;

}

}

int main()

{

sol();

return 0;

}

#include "pch.h"

#include <iostream>

#include <stdlib.h>

using namespace std;

const int MAX = 1001;

const int MOD = 10007;

int N, K;

int cache[MAX][MAX];

void init()

{

for (int i = 1; i <= N; i++)

{

cache[i][1] = i;

cache[i][i] = cache[i][0] = 1;

}

}

void sol()

{

for (int i = 3; i <= N; i++) {

for (int j = 2; j < i; j++) {

cache[i][j] = cache[i - 1][j] % MOD + cache[i - 1][j - 1] % MOD;

}

}

}

int main()

{

cin >> N >> K;

if (N < 1 || N >= MAX || K<0 || K>N)

exit(-1);

init();

sol();

cout << cache[N][K] %MOD << endl;

return 0;

}

#include "pch.h"

#include <iostream>

using namespace std;

//N<=10 K<=N 인 자연수

int sol(int n)

{

if (n == 0)

return 1;

int ret=1;

for (int i = n; i >= 1; i--)

ret *= i;

return ret;

}

int main()

{

int n, k;

cin >> n >> k;

cout << sol(n) / (sol(k)*sol(n - k));

return 0;

}

#include <iostream>

#include <algorithm>

#include <string.h>

using namespace std;

const int MAX = 1000;

int map[MAX];

int caseNum;

void solution()

{

    int tc;

    int ret=0, tmp=0;

    memset(map, 0, sizeof(map));

    caseNum++;

    scanf("%d", &tc);

    for(int i=0;i<tc;i++)

       scanf("%d", &map[i]);

    for(int i=2;i<tc-2;i++)

    {

        tmp = map[i] - max(max(map[i-1], map[i-2]), max(map[i+1], map[i+2])); 

        if(tmp > 0)

            ret+=tmp;

    }

    cout<<"#"<<caseNum<<" "<<ret<<endl;

}

int main(void)

{

    for(int i=0;i<10;i++)

        solution();

    return 0;   

} 

#include <iostream>

#include <string.h>

using namespace std;

const int STUDENT = 1000;

int T,testNum,ret;

int arr[101];

int main(void)

{

int score;

scanf("%d",&T);

while(T--)

{

int max=0;

memset(arr,0,sizeof(arr));

scanf("%d", &testNum);

for(int i=0; i<STUDENT; i++)

{

scanf("%d", &score);

arr[score]++;

if(arr[score]>max)

max=arr[score];

}

for(int i=0; i<101; i++)

{

if(arr[i]==max)

ret=i;

}

cout<<"#"<<testNum<<" "<<ret<<endl;

}

return 0;

} 

/****************************************************************************************************

자료구조 03 스택과 큐

2018.11.02

3.1 하나의 배열을 사용해 세 개의 스택을 구현

3.2 push와 pop 두 가지 연산과 함께 최솟값을 반환하는 min을 갖춘 스택을 구현

push, pop, min은 O(1)시간에 처리되도록 구현하시오

3.3 접시 무더기 높이가 특정 수준 이상으로 높아지면 새로운 무더기를 만드는 자료구조 SetOfStacks를 구현

SetOfStacks는 여러 스택으로 구성되어야 하며, 이전 스택이 지정된 용량을 초과하는 경우

새로운 스택을 생성해야 한다. push()와 pop()은 스택이 하나인 경우와 동일하게 동작하도록 구현하시오

3.4 하노이탑 문제 

한번에 하나만 옮길 수 있으며 탑의 맨 꼭대기에 있는 원판은 옆에 있는 탑으로 옮길 수 있다.

    원판은 자기보다 지름이 큰 원판 위로만 옮길 수 있다. 스택을 사용하여, 첫 번째 탑에 있는 모든 원판을

마지막 탑으로 옮기는 프로그램을 구현하시오.

****************************************************************************************************/ 

#include <iostream>

#include <algorithm>

#include <vector>

#include <string.h>

#include <string>

using namespace std;

//solve 3.1 -- start

const int STACKSIZE = 100;

int s[STACKSIZE * 3];

int top[3] = {-1, -1, -1}; //3개의 스택 top포인터

int getTop(int nStack)

{

return nStack*STACKSIZE + top[nStack];

}

void push(int nStack, int value)

{

top[nStack]++;

s[getTop(nStack)] = value;

}

int pop(int nStack)

{

int ret = s[getTop(nStack)];

s[getTop(nStack)] = 0; //value 0으로 초기화

top[nStack]--; //top값 1 감소

return ret;

} 

#include <iostream>

#include <algorithm>

#include <vector>

#include <string.h>

#include <string>

using namespace std;

// solve 3.2 push, pop, min O(1)시간 처리 스택 구현

typedef struct node {

int data;

struct node* next;

} Node;

class Stack {

private:

int cnt;

Node* top;

Node* minTop;

public:

Stack();

void push(int);

int pop();

int min();

bool isEmpty();

};

Stack::Stack() {

cnt=0;

top=NULL;

};

void Stack::push(int data) {

Node *newNode = new Node;

newNode->data=data;

if(isEmpty()) {

top=newNode;

minTop=newNode;

} else {

newNode->next=top;

top=newNode;

if(newNode->data <= minTop->data) {

newNode->next=minTop;

minTop=newNode;

}

}

}

int Stack::pop() {

if(isEmpty())

exit(1);

int ret=top->data;

if(minTop->data == ret) {

minTop=minTop->next;

}

top=top->next;

return ret;

}

int Stack::min() {

return minTop->data;

}

bool Stack::isEmpty() {

if( top == NULL )

return true;

else

return false;

}

public class UtilityClass {

     // 기본 생성자가 자동 생성되지 못하도록 하여 객체 생성 방지

     private UtilityClass() {

          throw new AssertionError();

     }

}

public class Sw{

     public static final Sw INSTANCE = new Sw();

     private Sw(){ ... }

     메소드...

}

public class Sw{

     private static final Sw INSTANCE = new Sw();

     private Sw() { ... }

     public static Sw getInstance() { return INSTANCE; }

}

public enum Sw{

     INSTANCE;

} 

 METHOD

CRUD 

POST 

Create 

GET

Read 

PUT

Update 

DELETE 

Delete 

Action 

Resource URI 

HTTP Method 

 사용자 목록

/users 

GET 

 사용자 보기

/users/{id} 

GET 

 사용자 등록

/users 

POST 

 사용자 수정

/users/{id} 

PUT 

 사용자 삭제

/users/{id} 

DELETE