스러피(Slurpy)

스러피(Slurpy)란 어떠한 속성이 존재하는 문자열이다. 문자열을 읽어서 스러피가 존재하는지를 판단하는 프로그램을 작성해야 한다.

스럼프(Slump)는 다음 속성을 갖는 문자열이다.

  • 첫 번째 문자가 'D' 또는 'E'이다.
  • 첫 번째 문자 뒤에는 하나 이상의 'F'가 나온다.
  • 하나 이상의 'F' 뒤에는 또 다른 스럼프나 'G'가 온다. 스럼프는 'F' 끝에 오는 스럼프나 'G'로끝난다. 예를 들어, DFFEFFFG는 첫 번째 문자가 'D'로 시작하고 두 개의 'F'가 나오며, 또 다른스럼프 'EFFFG'로 끝난다.
  • 위의 경우가 아니면 스럼프가 아니다.

스림프(Slimp)는 다음 속성을 갖는 문자열이다.

  • 첫 번째 문자는 'A'이다.
  • 두 개의 문자로만 된 스림프면, 두 번째 문자는 'H'이다.
  • 두 개의 문자로 된 스림프가 아니면 다음 형식 중의 하나가 된다.
    'A' + 'B' + 스림프 + 'C'.
    'A' + 스럼프 + 'C'.
  • 위의 경우가 아니면 스림프가 아니다.

스러피(Slurpy)는 스림프(Slimp) 뒤에 스럼프(Slump)로 구성되는 문자열이다.

다음은 그 예이다.

Slumps : DFG, EFG, DFFFFFG, DFDFDFDFG, DFEFFFFFG
Not Slumps: DFEFF, EFAHG, DEFG, DG, EFFFFDG
Slimps: AH, ABAHC, ABABAHCC, ADFGC, ADFFFFGC, ABAEFGCC, ADFDFGC
Not Slimps: ABC, ABAH, DFGC, ABABAHC, SLIMP, ADGC
Slurpys: AHDFG, ADFGCDFFFFFG, ABAEFGCCDFEFFFFFG
Not Slurpys: AHDFGA, DFGAH, ABABCC

입력

입력될 문자열의 개수를 나타내는 정수 N 이 1 ~ 10의 범위로 우선 입력된다. 다음 줄부터 N개의 문자열이 입력된다. 문자열은 1 ~ 60 개의 알파벳 문자로 구성된다.

출력

첫 줄에는 "SLURPYS OUTPUT"을 출력한다. N 개의 문자열 입력에 대해서 각 문자열이 스러피인지를 "YES" 또는 "NO"로 표기한다. 마지막으로 "END OF OUTPUT"를 출력한다.

Sample Input

2
AHDFG
DFGAH

Sample Output

SLURPYS OUTPUT
YES
NO
END OF OUTPUT
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

38개의 풀이가 있습니다. 4 / 4 Page

c++로 풀었습니다

#include <iostream>
#include <string>

bool isSlump(std::string target, int len);
bool isSlimp(std::string target, int len);
bool isSlurpy(std::string target, int len);
// print routine
inline void printBool(bool target)
{
    if(target) std::cout << "YES" << std::endl;
    else std::cout << "NO" << std::endl;
}

int main(void)
{
    using namespace std;
    int N;
    cin >> N;
    cin.get();

    // Allocate string pointer to store input strings
    string* str = new string[N];

    for(int i = 0; i < N; i++)
        getline(cin, str[i]);

    cout << "\nSLURPYS OUTPUT" << endl;

    for(int i = 0; i < N; i++)
        printBool(isSlurpy(str[i], str[i].length()));

    cout << "END OF OUTPUT" << endl;

    delete[] str;
}


bool isSlump(std::string target, int len)
{
    // length should be at least 3
    if(len < 3) return false;
    else
    {
        // first condition
        if(target[0] == 'D' || target[0] == 'E')
        {
            int countF = 0;
            int index;

            // count how many consecutive F are
            for(index = 1; index < len; index++)
            {
                if(target[index] == 'F')
                    countF++;
                else
                    break;
            }

            if(countF == 0) return false;
            else
            {
                // only one character left
                if(len - index == 1)
                {
                    if(target[index] == 'G') return true;
                }
                else return isSlump(target.substr(index, len), len - index);
            }
        }

        return false;
    }
}
bool isSlimp(std::string target, int len)
{
    // least length is 2
    if(len < 2) return false;
    else
    {
        if(target[0] == 'A')
        {
            if(len == 2)
            {
                if(target[1] == 'H')
                    return true;
            }
            else
            {
                if(target[1] == 'B' && target[len - 1] == 'C' && isSlimp(target.substr(2, len - 1), len - 3))
                    return true;
                else if(target[len - 1] == 'C' && isSlump(target.substr(1, len - 1), len - 2))
                    return true;
            }
        }
    }

    return false;
}

bool isSlurpy(std::string target, int len)
{
    // find where last C appear(end point of Slimp)
    int index = 1;

    for(int i = 0; i < len; i++)
    {
        if(target[i] == 'C')
            index = i;
    }
    index++;
    return isSlimp(target.substr(0, index), index) && isSlump(target.substr(index, len), len - index);
}

※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.
def isSlump(s):
    if len(s)<3:
        return False
    else:
        i = 0
        state = 1

        while state == 1:
            if s[i] == 'D' or 'E':
                i += 1
                if s[i] == 'F':
                    i += 1
                    while s[i] == 'F' and i != len(s)-1:
                        i += 1
                    if i == len(s)-1:
                        if s[i] == 'G':
                            state = 0
                            return True
                        else:
                            state = 0
                            return False
                else:
                    state = 0
                    return False
            else:
                state = 0
                return False

def unitSlimp(s):
    if len(s)<2:
        return False
    else:
        if s == 'AH':
            return True
        if s[0] == 'A' and s[-1] == 'C' and isSlump(s[1:-1]) == True:
            return True

def isSlimp(s):
    if len(s)<2:
        return False
    else:
        if unitSlimp(s) == True:
            return True
        else:
            i, j = 0, 0
            state = 1

            while state == 1:
                if s[i] == 'A' and s[i+1] == 'B':
                    if s[-j-1] == 'C':
                        i += 2
                        j += 1
                        if unitSlimp(s[i:-j]) == True:
                            state = 0
                            return True
                    else:
                        state = 0
                        return False
                else:
                    state = 0
                    return False

def isSlurpy(s):
    i=0
    while isSlimp(s[:i]) != True:
        i += 1
        if i == len(s):
            return "NO"
    if isSlump(s[i:]) == True:
        return "YES"
    else:
        return "NO"

n = int(input("Number of strings:"))

string = [input() for iter in range(n)]
print("\nSLURPYS OUTPUT")
for i in string:
    print(isSlurpy(i))
print("END OF OUTPUT")
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

문제의 예시는 모두 문제 없이 동작합니다.. 혹시나 오류가 있으면 알려주세요 ㅎㅎ 이렇게 풀어도 될지 모르겠네요

#include <iostream>
#include <vector>
#include <string>
using namespace std;

/* http://codingdojang.com/scode/327
스러피(Slurpy)란 어떠한 속성이 존재하는 문자열이다. 문자열을 읽어서 스러피가 존재하는지를 판단하는 프로그램을 작성해야 한다.

스럼프(Slump)는 다음 속성을 갖는 문자열이다.
첫 번째 문자가 'D' 또는 'E'이다.
첫 번째 문자 뒤에는 하나 이상의 'F'가 나온다.
하나 이상의 'F' 뒤에는 또 다른 스럼프나 'G'가 온다. 스럼프는 'F' 끝에 오는 스럼프나 'G'로끝난다.
예를 들어, DFFEFFFG는 첫 번째 문자가 'D'로 시작하고 두 개의 'F'가 나오며, 또 다른스럼프 'EFFFG'로 끝난다.
위의 경우가 아니면 스럼프가 아니다.

스림프(Slimp)는 다음 속성을 갖는 문자열이다.
첫 번째 문자는 'A'이다.
두 개의 문자로만 된 스림프면, 두 번째 문자는 'H'이다.
두 개의 문자로 된 스림프가 아니면 다음 형식 중의 하나가 된다.
'A' + 'B' + 스림프 + 'C'.
'A' + 스럼프 + 'C'.
위의 경우가 아니면 스림프가 아니다.

스러피(Slurpy)는 스림프(Slimp) 뒤에 스럼프(Slump)로 구성되는 문자열이다.

다음은 그 예이다.

Slumps : DFG, EFG, DFFFFFG, DFDFDFDFG, DFEFFFFFG
Not Slumps: DFEFF, EFAHG, DEFG, DG, EFFFFDG
Slimps: AH, ABAHC, ABABAHCC, ADFGC, ADFFFFGC, ABAEFGCC, ADFDFGC
Not Slimps: ABC, ABAH, DFGC, ABABAHC, SLIMP, ADGC
Slurpys: AHDFG, ADFGCDFFFFFG, ABAEFGCCDFEFFFFFG
Not Slurpys: AHDFGA, DFGAH, ABABCC
입력

입력될 문자열의 개수를 나타내는 정수 N 이 1 ~ 10의 범위로 우선 입력된다.
다음 줄부터 N개의 문자열이 입력된다.
문자열은 1 ~ 60 개의 알파벳 문자로 구성된다.

출력

첫 줄에는 "SLURPYS OUTPUT"을 출력한다.
N 개의 문자열 입력에 대해서 각 문자열이 스러피인지를 "YES" 또는 "NO"로 표기한다.
마지막으로 "END OF OUTPUT"를 출력한다.

Sample Input

2
AHDFG
DFGAH


Sample Output

SLURPYS OUTPUT
YES
NO
END OF OUTPUT
*/
bool checkSlump(string);
bool checkSlimp(string);
bool checkSlurpy(string);

int main() {
    int stringCount;
    string inputString;
    vector<string> vectorInputString;

    cin >> stringCount;
    if (stringCount < 0 || stringCount > 10) {
        cout << "stringCount error" << endl;
    }
    else {
        while (stringCount > 0) {
            cin >> inputString;
            if (inputString.length() == 0 || inputString.length() > 60) {
                cout << "inputString error" << endl;

                break;
            }

            vectorInputString.push_back(inputString);

            stringCount--;
        }
    }

    cout << endl;
    cout << "SLURPYS OUTPUT" << endl;
    for (int vectorIdx = 0; vectorIdx < vectorInputString.size(); vectorIdx++) {
        string str = vectorInputString[vectorIdx];

        cout << ((checkSlurpy(str)) ? "YES" : "NO") << endl;
    }
    cout << "END OF OUTPUT" << endl;

    system("pause");
    return 0;
}

bool checkSlump(string str) {
    if (str[0] == 'D' || str[0] == 'E') {
        if (str.find_first_of('F') != -1) {
            int indexOfFirstF = str.find_first_of('F');
            string afterF = str.substr(indexOfFirstF);

            if (checkSlump(afterF) || afterF[afterF.length() - 1] == 'G') {
                return true;
            }
        }
    }

    return false;
}

bool checkSlimp(string str) {
    if (str[0] == 'A') {
        if (str.length() == 2 && str[1] == 'H') {
            return true;
        }
        else if (str[1] == 'B' && str[str.length() - 1] == 'C') {
            int indexOfFirstB = str.find_first_of('B');
            string afterB = str.substr(str.find_first_of('B') + 1);

            if (checkSlimp(afterB.substr(0, afterB.length() - 1))) {
                return true;
            }
        }
        else if (str[1] != 'B' && str[str.length() - 1] == 'C') {
            string expectedSlump = str.substr(1, str.length() - 2);

            if (checkSlump(expectedSlump)) {
                return true;
            }
        }
    }

    return false;
}

bool checkSlurpy(string str) {
    // 인덱스 0 ~ 1, 0 ~ 2, 0 ~ 3,... 이 스림프인 지 판단 후 스림프라면 나머지 문자열이 스럼프인 지 판단
    int expectedSlimpLength;

    for (expectedSlimpLength = 1; expectedSlimpLength < str.length() - 1; expectedSlimpLength++) {
        if (checkSlimp(str.substr(0, expectedSlimpLength))) {
            string expectedSlump = str.substr(expectedSlimpLength, str.length() - expectedSlimpLength);

            return checkSlump(expectedSlump);
        }
    }

    return false;
}
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.
import re
slumps=re.compile("[D|E]F+([D|E]F+)*G")
slimps=re.compile("AH|A([D|E]F+([D|E]F+)*G)+C|AB(AH|A[D|E]F+([D|E]F+)*G+C|AB)+C")

def match_slump(h):    
    m=slumps.match(h)
    if m:
        print("match")
    else :
        print("NONE")

def match_slimp(h):    
    m=slimps.match(h)
    if m:
        print("match")
    else :
        print("NONE")

def match_slurpy(h):    
    m=slimps.match(h)
    if m:
        tmp=h[len(m.group()):]
        tp=slumps.match(tmp)
        if tp:
            print("YES")
        else:
            print("NO")

    else:
        print("NO")

number_input=int(input())
string=[]
for i in range(number_input):
    arr=input()
    string.append(arr)

print("SLURPYS OUTPUT")
for i in range(number_input):
    match_slurpy(string[i])
print("END OF OUTPUT")



※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

javascript(ES6)

크롬 개발자도구에서 하려니 입력이 자유롭지 못하네요 ;(

자바스크립트 프로토타입 사랑합니다 ^^

// isSlump 는 쓰이지 않는 코드입니다. 확인용으로 작성
String.prototype.isSlump = function() {
    var m =/^([DE]F+)+G$/g.exec(this);
    return m !== null;
};

String.prototype.isSlimp = function () {
    var m = /^(?:AH|A(?:[DE]F+)+GC|AB(.+)C)$/g.exec(this);
    return m ? !m[1] || m[1].isSlimp() : false;
};

String.prototype.isSlurpy = function() {
    var m = /^(?:AH|A(?:[DE]F+)+GC|AB(.+)C)(?:[DE]F+)+G$/g.exec(this);
    return m ? !m[1] || m[1].isSlimp() : false;
};

var input = 
`2
AHDFG
DFGAH`;

var lines = input.split("\n");
var length = parseInt(lines[0]);

console.log("SLURPYS OUTPUT");
for (let i = 1; i <= length; i++) {
    console.log(lines[i].isSlurpy() ? "YES" : "NO");
}
console.log("END OF OUTPUT");
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

[Python 3.6]

import regex
slump_pat = regex.compile('([DE]F+)+G')
slimp_pat = regex.compile('AH|A([DE]F+)+GC|AB(?R)C')
def check_slurpy(data):
    print("SLURPYS OUTPUT")
    datalines = data.strip().split("\n")
    for i in range(1, int(datalines[0])+1):
        m = slimp_pat.match(datalines[i])
        if m and slump_pat.fullmatch(datalines[i][m.end():]): print(True)
        else: print(False)
    print("END OF OUTPUT")
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

JAVA입니다

package example170703;

import java.util.Scanner;

/*
 * 스러피 구하기!
 * 스러피 = 스림프 + 스럼프
 * 
 * 스럼프는
 * 첫 번째 문자가 'D' 또는 'E'이다. 
 * 첫 번째 문자 뒤에는 하나 이상의 'F'가 나온다. 
 * 하나 이상의 'F' 뒤에는 또 다른 스럼프나 'G'가 온다. 스럼프는 'F' 끝에 오는 스럼프나 'G'로끝난다. 예를 들어, DFFEFFFG는 첫 번째 문자가 'D'로 시작하고 두 개의 'F'가 나오며, 또 다른스럼프 'EFFFG'로 끝난다. 
 * 위의 경우가 아니면 스럼프가 아니다.
 * 
 *  스림프는
 *  첫 번째 문자는 'A'이다. 
 *  두 개의 문자로만 된 스림프면, 두 번째 문자는 'H'이다. 
 *  두 개의 문자로 된 스림프가 아니면 다음 형식 중의 하나가 된다.
 *  'A' + 'B' + 스림프 + 'C'. 
 *  'A' + 스럼프 + 'C'. 
 *  위의 경우가 아니면 스림프가 아니다. 
 */
public class Ex013 {
    static int strNum;
    static String[] strs = null;
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        //입력
        getInputData();


        System.out.println("SLURPY OUTPUT");
        for(int i=0; i< strs.length; i++) {
            if(isSlurpy(strs[i]))
                System.out.println("YES");
            else
                System.out.println("NO");
        }
        System.out.println("END OF OUTPUT");

    }

    //스러피 검사
    static boolean isSlurpy(String str) {
        boolean findSlump = false;
        boolean findSlimp = false;
        int chkPosi;

        if((chkPosi = isSlimp(str)) != -1)
            findSlimp = true;


        //앞에서 스림프가 발견되지 않았으면 스러피가 아니다.
        if(!findSlimp)
            return false;

        //스림프 뒤에 남은 문자열의 문자개수가 3개 미만이라면 스럼프는 존재할 수 없다.
        //따라서 스러피도 존재할 수 없다.
        if(chkPosi+2 > str.length()-1)
            return false;

        //스림프 뒤에 남은 문자열이 스럼프인지 검사.
        //스럼프가 아니라면 스러피가 아니다.
        int idx;
        if((idx = isSlump(str.substring(chkPosi+1))) != -1) {
            if( (str.length()-1) != (chkPosi+1 + idx) )
                return false;
            else
                return true;
        }
        else 
            return false;
    }

    //스럼프 검사
    //반환: 스럼프가 찾아진 끝 index반환, 찾지 못했다면 -1 반환
    static int isSlump(String str) {
        boolean foundF = false;
        boolean foundSlump = false;
        for(int i=0; i < str.length(); i++) {
            //첫문자 검사
            if(i == 0) {
                //첫문자가 D,F가 아니라면 스럼프가 아니다. -1반환
                if(!(str.charAt(i) == 'D') && !(str.charAt(i) == 'E')) 
                    return -1;
                else
                    continue;
            }

            //F나오는지 검사
            if(str.charAt(i) == 'F') {
                foundF = true;
                continue;
            }

            //첫번째 문자가 아니면서 D,E면 다시 스럼프인지 검사.
            if(str.charAt(i) == 'D' || str.charAt(i) == 'E') {
                //이전에 F가 나오지 않았다면  -1반환
                if(foundF == false) 
                    return -1;
                int idx;
                //이전에 'F'가 나왔다면 해당 substring이 스럼프인지 다시 검사
                if((idx = isSlump(str.substring(i))) != -1) {
                    if(foundF == true) {
                        i+=(idx-1);
                        continue;
                    }
                }
                else
                    return -1;
            }

            //스럼프 마지막문자 G가 나오면 완벽한 스럼프(첫문자가 DE,F있는지)인지 검사
            if(str.charAt(i) == 'G') {
                if(foundF == true)
                    return i;
                else 
                    return -1;
            }
        }

        return -1;
    }

    //스림프 검사
    //찾아진 스림프의 의 마지막 인덱스를 반환, 스림프가 아니면 -1반환
    static int isSlimp(String str) {
        boolean foundSlimp = false;
        boolean foundSlump = false;

        //문자열을 탐색해가며 검사
        for(int i=0; i < str.length(); i++) {
            //첫 문자 검사
            if(i == 0) {
                //첫문자가 A가 아니라면 스림프가 아니다. -1반환
                if(!(str.charAt(i) == 'A'))
                    return -1;
                else {
                    if(str.charAt(i+1) == 'H')
                        return i+1;
                    continue;
                }
            }

            //마지막 문자C를 만나면 올바른 스림프인지 검사
            if( (str.charAt(i) == 'C' && foundSlimp) 
                    || (str.charAt(i) == 'C' && foundSlump) )
                return i;

            //'A'+'B'+스림프+'C' 형태인지 검사  // 'A'+스럼프+'C' 형태인지 검사
            if(str.charAt(1) == 'B') {
                int idx;
                if((idx =isSlimp(str.substring(i+1))) != -1) {
                    foundSlimp = true;
                    i+=(idx+1);
                }
                else 
                    return -1;
            }
            else {
                int idx;
                //substring은 현재 문자열의 맨 마지막 문자('C')를 제외하고 준다.
                if((idx = isSlump(str.substring(i))) != -1) {
                    foundSlump = true;
                    i+=idx;
                }
                else 
                    return -1;
            }

        }
        return -1;
    }

    //입력
    static void getInputData() {
        Scanner scan = new Scanner(System.in);
        do {
            System.out.print("문자열 개수: ");
            strNum = scan.nextInt();
        }while(strNum < 1);

        strs = new String[strNum];

        for(int i=0; i<strNum; i++) {
            do {
                strs[i] = scan.nextLine();
            }while(strs[i].replaceAll(" ", "").equals(""));
        }
        System.out.println();
    }
}

설계를 잘못해서 코드가 왕창 꼬여버렸어요.ㅠㅠ 스럼프,스림프 재귀함수이고 스러피 함수에서 스럼프,스림프 이용하여 스러피를 구합니다. 주석 부실 죄송합니다ㅠ

※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

Python3: 짭오토마타

정규식은 많이들 하신 거 같아서, 오토마타로 도전(?)해 봤습니다. 재밌을 거 같아서요.

짭오토마타 그림

(이미지 업로드는 아마 안 되는 거 같죠...?)

.

Slurpy = Slimp + Slump 인데,

그림에서 0~3번 상태는 Slimp, 4번 상태는 Slimp->Slump를 연결하고, 5~7번 상태는 Slump 입니다.

손으로 끄적거려 보니 Slump는 DFA로 표현 가능합니다.

문제는 Slimp의 재귀적인 구조인데, 각 Slimp의 마지막에 오는 'C'만 제외하면 역시 표현이 됩니다.

그래서 변수 C를 추가해서, 각 Slimp의 마지막에 입력되어야 하는 'C'의 개수를 저장하도록 했습니다.

Slimp를 재귀적으로 구현했을 때 depth를 저장한다고 봐도 됩니다.

.

두 가지 경우에 상태5로 들어가는데(Slump 시작),

1->5 로 전이하는 경우는 Slimp에 포함된 Slump이고,

반드시 C가 0 이상(종료되지 않은 Slimp가 있음)인 채로 들어오기 때문에 7(Slump가 종료된 상태)에서 3으로 돌아가 끝나지 않은 Slimp를 마무리 짓게 됩니다.

반면 3->4->5로 전이하는 경우는 C==0, 즉 모든 Slimp가 마무리되었고 Slurpy의 뒤에 오는 마지막 Slimp만 검사하고 끝납니다.

(말로 하면 간단한데 생전 처음 해 보는 짓이라 많이 헤맸습니다T.T. 정규식 표현이 되니까 NFA로는 될 거 같은데 솔직히 NFA는 잘 기억 안 나서..)

.

상태전이 화살표를 두 종류로 나누었는데, trans(transitions)는

(현재상태, 입력문자):(다음상태, C 변화량)

으로 이루어진 사전입니다. 일반적인 상태 전이에 더해서 C의 값을 더하거나 뺍니다.

cond(conditional transitions)는

(현재상태, C값):다음상태

로 이루어진 사전입니다. 그림에 입실론으로 적었듯, 현재상태와 현재 C값만 맞으면 입력문자 없이 바로 상태가 전이됩니다.

trans  = {(0,'A'):(1,1),
          (1,'B'):(2,0), (1,'D'):(5,0), (1,'E'):(5,0), (1,'H'):(3,-1),
          (2,'A'):(1,1),
          (3,'C'):(3,-1),
          (4,'D'):(5,0), (4,'E'):(5,0), 
          (5,'F'):(6,0), 
          (6,'F'):(6,0), (6,'D'):(5,0), (6,'E'):(5,0), (6,'G'):(7,0),
          (7,'C'):(3,-1)}

cond    = {(3,0):4, (3,-1):8}

def isslurpy(s):
    state = 0
    C = 0
    for ch in s:
        if (state, ch) in trans:
            state , diff = trans[(state, ch)];
            C += diff
        else:
            return 'NO'

        if (state, C) in cond:
            state = cond[(state, C)]

    return 'YES' if state is 7 and C is 0 else 'NO'
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

풀이 작성

※ 풀이작성 안내
  • 본문에 코드를 삽입할 경우 에디터 우측 상단의 "코드삽입" 버튼을 이용 해 주세요.
  • 마크다운 문법으로 본문을 작성 해 주세요.
  • 풀이를 읽는 사람들을 위하여 풀이에 대한 설명도 부탁드려요. (아이디어나 사용한 알고리즘 또는 참고한 자료등)
  • 작성한 풀이는 다른 사람(빨간띠 이상)에 의해서 내용이 개선될 수 있습니다.
목록으로
코딩도장

코딩도장은 프로그래밍 문제풀이를 통해서 코딩 실력을 수련(Practice)하는 곳입니다.


언어별 풀이 현황
전 체 x 38
ruby x 2
python x 14
기 타 x 5
cpp x 7
java x 5
cs x 1
perl x 1
haskell x 1
go x 1
javascript x 1