스러피(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
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

35개의 풀이가 있습니다. 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");
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

풀이 작성

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

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


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