스러피(Slurpy)란 어떠한 속성이 존재하는 문자열이다. 문자열을 읽어서 스러피가 존재하는지를 판단하는 프로그램을 작성해야 한다.
스럼프(Slump)는 다음 속성을 갖는 문자열이다.
스림프(Slimp)는 다음 속성을 갖는 문자열이다.
스러피(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
72개의 풀이가 있습니다.
Ruby
slumpPattern = /([DE]F+)+G/
slimpPattern = /(?<slimp>AH|AB\g<slimp>C|A#{slumpPattern}C)/
slurpyPattern = /#{slimpPattern}#{slumpPattern}/
n = gets.to_i
puts "SLURPYS OUTPUT"
n.times{
line = gets.strip
if line =~ /^#{slurpyPattern}$/
puts "YES"
else
puts "NO"
end
}
puts "END OF OUTPUT"
Python3로 작성하였습니다.
import regex as re
# regular expression
reSlump = re.compile("([D|E]F+G*)+G")
reSlimp = re.compile("AH|A([D|E]F+G*)+GC|AB(?R)C")
# test slurpy
def testSlurpy(testCase):
m = re.match(reSlimp, testCase)
if m:
postFix = testCase[len(m.group()):]
return re.fullmatch(reSlump, postFix) != None
else:
return False
if __name__ == "__main__":
n = input("input test count : ")
testCases = [input("Test case " + str(i+1) + " : ").upper() for i in range(int(n))]
print("-"*50)
print("SLURPYS OUTPUT")
for testCase in testCases:
print("YES" if testSlurpy(testCase) else "NO")
print("END OF OUTPUT")
결과
input test count : 2
Test case 1 : AHDFG
Test case 2 : DFGAH
--------------------------------------------------
SLURPYS OUTPUT
YES
NO
END OF OUTPUT
풀이가 좀 길어서 제 블로그에 올렸습니다 ^^
코드는 아래와 같습니다. State Pattern을 사용하였습니다.
unit Slurpy;
interface
uses
Classes, SysUtils;
type
TSlurpy = class;
TState = class abstract
private
FSlurpy : TSlurpy;
public
constructor Create(ASlurpy:TSlurpy); reintroduce;
procedure SetState(AState:TState);
function Next:AnsiChar;
function Peek(ACount:integer):AnsiChar;
procedure Execute; virtual; abstract;
end;
TSlurpy = class
private
FIsFinished : boolean;
private
FState : TState;
FStateSlimpBase : TState;
FStateSlimpA : TState;
FStateSlimpASlump : TState;
FStateSlimpAB : TState;
FStateSlimpABSlimp : TState;
FStateSlumpBase : TState;
FStateSlumpD : TState;
FStateSlumpDF : TState;
FStateSlumpE : TState;
FStateSlumpEF : TState;
private
FSource: AnsiString;
FIndex : integer;
procedure SetSource(const Value: AnsiString);
public
constructor Create;
destructor Destroy; override;
function Next:AnsiChar;
function Peek(ACount:integer):AnsiChar;
function IsSlurpy:boolean;
function IsSlimp:boolean;
function IsSlump:boolean;
function IsF:boolean;
property Source : AnsiString read FSource write SetSource;
end;
implementation
type
TStateSlimpBase = class (TState)
private
public
procedure Execute; override;
end;
TStateSlimpA = class (TState)
private
public
procedure Execute; override;
end;
TStateSlimpAB = class (TState)
private
public
procedure Execute; override;
end;
TStateSlimpABSlimp = class (TState)
private
public
procedure Execute; override;
end;
TStateSlimpASlump = class (TState)
private
public
procedure Execute; override;
end;
TStateSlumpBase = class (TState)
private
public
procedure Execute; override;
end;
TStateSlumpD = class (TState)
private
public
procedure Execute; override;
end;
TStateSlumpDF = class (TState)
private
public
procedure Execute; override;
end;
TStateSlumpE = class (TState)
private
public
procedure Execute; override;
end;
TStateSlumpEF = class (TState)
private
public
procedure Execute; override;
end;
{ TState }
constructor TState.Create(ASlurpy:TSlurpy);
begin
inherited Create;
FSlurpy := ASlurpy;
end;
function TState.Next: AnsiChar;
begin
Result := FSlurpy.Next;
end;
function TState.Peek(ACount: integer): AnsiChar;
begin
Result := FSlurpy.Peek(ACount);
end;
procedure TState.SetState(AState: TState);
begin
FSlurpy.FIsFinished := false;
FSlurpy.FState := AState;
end;
{ TSlurpy }
constructor TSlurpy.Create;
begin
inherited;
FStateSlimpBase := TStateSlimpBase.Create(Self);
FStateSlimpA := TStateSlimpA.Create(Self);
FStateSlimpAB := TStateSlimpAB.Create(Self);
FStateSlimpABSlimp := TStateSlimpABSlimp.Create(Self);
FStateSlimpASlump := TStateSlimpASlump.Create(Self);
FStateSlumpBase := TStateSlumpBase.Create(Self);
FStateSlumpD := TStateSlumpD.Create(Self);
FStateSlumpDF := TStateSlumpDF.Create(Self);
FStateSlumpE := TStateSlumpE.Create(Self);
FStateSlumpEF := TStateSlumpEF.Create(Self);
end;
destructor TSlurpy.Destroy;
begin
FreeAndNil(FStateSlimpBase);
FreeAndNil(FStateSlimpA);
FreeAndNil(FStateSlimpAB);
FreeAndNil(FStateSlimpABSlimp);
FreeAndNil(FStateSlimpASlump);
FreeAndNil(FStateSlumpBase);
FreeAndNil(FStateSlumpD);
FreeAndNil(FStateSlumpDF);
FreeAndNil(FStateSlumpE);
FreeAndNil(FStateSlumpEF);
inherited;
end;
function TSlurpy.IsF: boolean;
begin
Result := false;
if Peek(1) <> 'F' then Exit;
Result := true;
while Peek(1) = 'F' do Next;
end;
function TSlurpy.IsSlurpy: boolean;
begin
try
Result := IsSlimp and IsSlump;
except
Result := false;
end;
end;
function TSlurpy.IsSlimp: boolean;
begin
try
FState := FStateSlimpBase;
FIsFinished := false;
repeat
FState.Execute;
until FIsFinished;
Result := true;
except
Result := false;
end;
end;
function TSlurpy.IsSlump: boolean;
begin
try
FState := FStateSlumpBase;
FIsFinished := false;
repeat
FState.Execute;
until FIsFinished;
Result := true;
except
Result := false;
end;
end;
function GetFirstChar(AStr:AnsiString):AnsiChar;
begin
if AStr = '' then Result := #0
else Result := AStr[1];
end;
function TSlurpy.Next: AnsiChar;
begin
FIndex := FIndex + 1;
Result := GetFirstChar(Copy(FSource, FIndex, 1));
end;
function TSlurpy.Peek(ACount: integer): AnsiChar;
begin
Result := GetFirstChar(Copy(FSource, FIndex + ACount, 1));
end;
procedure TSlurpy.SetSource(const Value: AnsiString);
begin
FIndex := 0;
FSource := Value;
end;
{ TStateSlimpBase }
procedure TStateSlimpBase.Execute;
begin
case Next of
'A': begin
SetState(FSlurpy.FStateSlimpA);
end;
else raise Exception.Create('Error in ' + ClassName);
end;
end;
{ TStateSlimpA }
procedure TStateSlimpA.Execute;
begin
case Peek(1) of
'H': begin
Next;
FSlurpy.FIsFinished := true;
end;
'B': begin
Next;
SetState(FSlurpy.FStateSlimpAB);
end;
else begin
if FSlurpy.IsSlump then FSlurpy.FState := FSlurpy.FStateSlimpASlump
else raise Exception.Create('Error in ' + ClassName);
end;
end;
end;
{ TStateSlimpAB }
procedure TStateSlimpAB.Execute;
begin
if FSlurpy.IsSlimp then SetState(FSlurpy.FStateSlimpABSlimp)
else raise Exception.Create('Error in ' + ClassName);
end;
{ TStateSlimpABSlimp }
procedure TStateSlimpABSlimp.Execute;
begin
case Next of
'C': begin
FSlurpy.FIsFinished := true;
end;
else raise Exception.Create('Error in ' + ClassName);
end;
end;
{ TStateSlimpASlimp }
procedure TStateSlimpASlump.Execute;
begin
case Next of
'C': begin
FSlurpy.FIsFinished := true;
end;
else raise Exception.Create('Error in ' + ClassName);
end;
end;
{ TStateSlumpBase }
procedure TStateSlumpBase.Execute;
begin
case Next of
'D': begin
SetState(FSlurpy.FStateSlumpD);
end;
'E': begin
SetState(FSlurpy.FStateSlumpE);
end;
else raise Exception.Create('Error in ' + ClassName);
end;
end;
{ TStateSlumpD }
procedure TStateSlumpD.Execute;
begin
if FSlurpy.IsF then SetState(FSlurpy.FStateSlumpDF)
else raise Exception.Create('Error in ' + ClassName);
end;
{ TStateSlumpDF }
procedure TStateSlumpDF.Execute;
begin
if Peek(1) = 'G' then begin
Next;
FSlurpy.FIsFinished := true;
end else begin
if FSlurpy.IsSlump then FSlurpy.FIsFinished := true
else raise Exception.Create('Error in ' + ClassName);
end;
end;
{ TStateSlumpE }
procedure TStateSlumpE.Execute;
begin
if FSlurpy.IsF then SetState(FSlurpy.FStateSlumpEF)
else raise Exception.Create('Error in ' + ClassName);
end;
{ TStateSlumpEF }
procedure TStateSlumpEF.Execute;
begin
if Peek(1) = 'G' then begin
Next;
FSlurpy.FIsFinished := true;
end else begin
if FSlurpy.IsSlump then FSlurpy.FIsFinished := true
else raise Exception.Create('Error in ' + ClassName);
end;
end;
end.
Sub Main()
Dim cnt As Integer = Val(Console.ReadLine)
Dim arr As New List(Of String)
For i As Integer = 1 To cnt
arr.Add(Console.ReadLine)
Next
Console.WriteLine("SLURPYS OUTPUT")
For Each s As String In arr
Console.WriteLine({"YES", "NO"}(CInt(Regex.IsMatch(s, "(?<g>AH|AB\G<g>C|A([DE]F+)+GC)([DE]F+)+G")) + 1))
Next
Console.WriteLine("END OF OUTPUT")
Console.ReadLine()
End Sub
저도 답변 하나 올려봅니다.
예전에 파이썬으로 풀었던 방법입니다.
import unittest
class UnitPattern:
def __init__(self, *args):
self.args = args
self._remain = ''
def match(self, target):
raise NotImplementedError
def remain(self):
return self._remain
class Word(UnitPattern):
def match(self, target):
if not target: return False
self._remain = target[1:]
return self.args[0][0] == target[0]
class And(UnitPattern):
def match(self, target):
for arg in self.args:
if not arg.match(target):
return False
target = arg.remain()
self._remain = target
return True
class Or(UnitPattern):
def match(self, target):
for arg in self.args:
if arg.match(target):
self._remain = arg.remain()
return True
return False
class More(UnitPattern):
def match(self, target):
if not target: return False
moreword = self.args[0][0]
for count, t in enumerate(target):
if t != moreword:
if count == 0 : return False
break
self._remain = target[count:]
return True
class MultiPattern:
def match(self, target):
return self.pat.match(target)
def remain(self):
return self.pat.remain()
class Slump(MultiPattern):
''' slump - (D or E) and F+ and (slump or G) '''
def __init__(self):
self.pat = And(
Or(Word('D'), Word('E')),
More('F'),
Or(self, Word('G'))
)
class Slimp(MultiPattern):
''' slimp - A and (H or ((B and slimp and C) or (slump and C)) '''
def __init__(self):
self.pat = And(
Word('A'),
Or(
Word('H'),
Or(
And(Word('B'), self, Word('C')),
And(Slump(), Word('C'))
)
)
)
class Slurpy(MultiPattern):
''' slurpy (slimp and slump) '''
def __init__(self):
self.pat = And(Slimp(), Slump())
def isSlurpy(target):
pat = Slurpy()
result = pat.match(target)
if pat.remain(): return False
return result
class SlurpyTest(unittest.TestCase):
def testWord(self):
word = Word('D')
self.assertEquals(True, word.match('DEF'))
self.assertEquals('EF', word.remain())
def testAnd(self):
D = Word('D')
E = Word('E')
andDE = And(D,E)
self.assertEquals(True, andDE.match('DE'))
def testMore(self):
self.assertEquals(True, More('F').match('FFFF'))
self.assertEquals(True, And(Word('D'), More('F')).match('DFFF'))
more = More('F')
more.match('FGHG')
self.assertEquals('GHG', more.remain())
def testOr(self):
self.assertEquals(True, Or(Word('F'), Word('E')).match('F'))
self.assertEquals(True, Or(Word('F'), Word('E')).match('E'))
self.assertEquals(True,
And(More('K'), Or(Word('F'), Word('E'))).match('KKKKE'))
def testSlump(self):
#Slumps : DFG, EFG, DFFFFFG, DFDFDFDFG, DFEFFFFFG
self.assertEquals(True, Slump().match('DFG'))
self.assertEquals(True, Slump().match('EFG'))
self.assertEquals(True, Slump().match('DFFFFFG'))
self.assertEquals(True, Slump().match('DFDFDFDFG'))
self.assertEquals(True, Slump().match('DFEFFFFFG'))
#Not Slumps : DFEFF, EFAHG, DEFG, DG, EFFFFDG
self.assertEquals(False, Slump().match('DFEFF'))
self.assertEquals(False, Slump().match('EFAHG'))
self.assertEquals(False, Slump().match('DEFG'))
self.assertEquals(False, Slump().match('DG'))
self.assertEquals(False, Slump().match('EFFFFDG'))
def testSlimp(self):
#Slimps: AH, ABAHC, ABABAHCC, ADFGC, ADFFFFGC, ABAEFGCC, ADFDFGC
self.assertEquals(True, Slimp().match('AH'))
self.assertEquals(True, Slimp().match('ABAHC'))
self.assertEquals(True, Slimp().match('ABABAHCC'))
self.assertEquals(True, Slimp().match('ADFGC'))
self.assertEquals(True, Slimp().match('ADFFFFGC'))
self.assertEquals(True, Slimp().match('ABAEFGCC'))
self.assertEquals(True, Slimp().match('ADFDFGC'))
#Not Slimps: ABC, ABAH, DFGC, ABABAHC, SLIMP, ADGC
self.assertEquals(False, Slimp().match('ABC'))
self.assertEquals(False, Slimp().match('ABAH'))
self.assertEquals(False, Slimp().match('DFGC'))
self.assertEquals(False, Slimp().match('ABABAHC'))
self.assertEquals(False, Slimp().match('SLIMP'))
self.assertEquals(False, Slimp().match('ADGC'))
def testSlurpy(self):
#Slurpys: AHDFG, ADFGCDFFFFFG, ABAEFGCCDFEFFFFFG
self.assertEquals(True, isSlurpy('AHDFG'))
self.assertEquals(True, isSlurpy('ADFGCDFFFFFG'))
self.assertEquals(True, isSlurpy('ABAEFGCCDFEFFFFFG'))
#Not Slurpys: AHDFGA, DFGAH, ABABCC
self.assertEquals(False, isSlurpy('AHDFGA'))
self.assertEquals(False, isSlurpy('DFGAH'))
self.assertEquals(False, isSlurpy('ABABCC'))
import sys
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(SlurpyTest))
unittest.TextTestRunner(verbosity=2, stream=sys.stdout).run(suite)
무식하게 풀어봤습니다.
#include <stdio.h>
#include <string.h>
int is_slump(const char *str, int n)
{
if (n < 3) return 0;
if (str[0] != 'D' && str[0] != 'E') return 0;
if (str[1] != 'F') return 0;
int i = 2;
while (str[i] == 'F' && i < n - 1) i++;
if (i == n - 1 && str[i] == 'G')
return 1;
if (is_slump(str + i, n - i))
return 1;
return 0;
}
int is_slimp(const char *str, int n)
{
if (n < 2) return 0;
if (str[0] != 'A') return 0;
if (n == 2) {
if (str[1] == 'H') return 1;
else return 0;
}
if (str[1] == 'B' && str[n - 1] == 'C' && is_slimp(str + 2, n - 3))
return 1;
if (str[n - 1] == 'C' && is_slump(str + 1, n - 2))
return 1;
return 0;
}
int is_slurpy(const char *str, int n)
{
int i;
for (i = 0; i < n; i++) {
if (is_slimp(str, i) && is_slump(str + i, n - i))
return 1;
}
return 0;
}
int main(int argc, char *argv[])
{
int n, i;
char str[61];
scanf("%d", &n);
printf("SLURPYS OUTPUT\n");
for (i = 0; i < n; i++) {
scanf("%s", str);
if (is_slurpy(str, strlen(str)))
printf("YES\n");
else
printf("NO\n");
}
printf("END OF OUTPUT\n");
return 0;
}
JAVA입니당
package h_slurpy;
public class Check {
int i,j;
boolean slump(String S, int a, int b){
if(S.charAt(a)=='D'||S.charAt(a)=='E'){ //첫글자는 D,E
for(i=a+1;i<b;i++) if(S.charAt(i)!='F') break;
if(i>a+1&&i<b){ //두번째글자부터 하나이상 F
if(i==b-1 && S.charAt(i)=='G') return true; //F뒤에는 'G'로 끝남
else if( slump(S,i,b) ) return true; //F뒤 또다른 slump일 경우
else return false;
} else return false;
} else return false;
}
boolean slimp(String S, int a, int b){
if(S.charAt(a)=='A'){ //첫글자는 A
if(a+2==b && S.charAt(a+1)=='H') return true; //두글자 AH
else if(S.charAt(a+1)=='B' && S.charAt(b-1)=='C' && slimp(S, a+2, b-1)) return true;
else if(S.charAt(b-1)=='C' && slump(S, a+1, b-1)) return true;
else return false;
} else return false;
}
boolean slurpy(String S){
int l=S.length(); int d;
for(i=l-1;i>=0;i--) if(S.charAt(i)=='C'||S.charAt(i)=='H') break;
if(i<0) return false;
else{
d=i+1;
if( slimp(S, 0, d) && slump(S, d, l) ) return true;
else return false;
}
}
}
package h_slurpy;
import java.util.Scanner;
public class Slurpy {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
Check C=new Check();
int N, i;
N=in.nextInt();
while(!(N>0&&N<=10)){ System.out.print("N:1~10의 정수. 다시입력해주세요"); N=in.nextInt();}
String[] input=new String[N];
for(i=0;i<N;i++) input[i]=in.next(); //input[i]는 1~60개의 알파벳문자
System.out.println("SLURPYS OUTPUT");
for(i=0;i<N;i++){
if(C.slurpy(input[i])) System.out.println("YES");
else System.out.println("NO");
}
System.out.println("END OF OUTPUT");
}
}
C#으로 작성했습니다. 문제를 처음에 잘못 읽어서 마지막에 헤맸네요. 단순히 char 하나하나씩 체크하는 방식으로 코딩 했습니다.
public bool IsSlump(string input)
{
var isSlump = false;
if (input.Length <= 2) return false;
if ((input[0] == 'D' || input[0] == 'E') && input[1] == 'F')
for (int i = 2; i < input.Length; i++)
{
if (input[i] == 'F') continue;
if ((input[i] == 'D' || input[i] == 'E') && input[i + 1] == 'F')
isSlump = IsSlump(input.Substring(i)); // a new slump
else if (i == input.Length - 1 && input[i] == 'G')
{
isSlump = true;
break; // slump ends
}
else break;
}
return isSlump;
}
public bool IsSlimp(string input)
{
var isSlimp = false;
if (input[0] == 'D' || input[0] == 'E') // slump comes
{
var i = input.IndexOf('G');
if (i > 0) isSlimp = IsSlump(input.Substring(0, i - 1));
return isSlimp;
}
if (input[0] == 'H') // slimp ends
return IsSlump(input.Substring(1));
if (input[0] == 'B') // slump inside slimp
{
var i = input.IndexOf('C');
if (i > 0) isSlimp = IsSlurpy(input.Substring(1, i - 1));
// slimp ends
if (isSlimp) isSlimp = IsSlimp(input.Substring(i + 2));
}
return isSlimp;
}
public bool IsSlurpy(string input)
{
input = input.ToUpper();
// it has to end with slump
if (input[input.Length - 1] != 'G') return false;
// slimp begins
if (input[0] == 'A') return IsSlimp(input.Substring(1));
return false;
}
def is_slurpy(s):
l = len(s)
if l < 5:
return False
for i in range(2, l-1):
slimp = s[0:i]
slump = s[i:]
if is_slimp(slimp) and is_slump(slump):
return True
return False
def is_slump(s):
l = len(s)
if l < 3:
return False
if s[0] != 'D' and s[0] != 'E':
return False
i = 1
while i < l and s[i] == 'F':
i += 1
if i == 1:
return False
rest = s[i:]
if rest == 'G':
return True
else:
return is_slump(rest)
def is_slimp(s):
l = len(s)
if l < 2:
return False
if s[0] != 'A':
return False
if l == 2:
return (s[1] == 'H')
if s[1] == 'B' and s[-1] == 'C':
slimp = s[2:-1]
return is_slimp(slimp)
if s[-1] == 'C':
slump = s[1:-1]
return is_slump(slump)
return False
print('SLURPYS OUTPUT')
c = int(raw_input())
while c:
if is_slurpy(raw_input()):
print('YES')
else:
print('NO')
c -= 1
print('END OF OUTPUT')
단순무식하게 풀었습니다.
Perl
루비나 펄이나..
use strict;
my ($ump,$imp,@a,@R);
$ump=qr/(?:[DE]F+)+G/;
$imp=qr/(?<imp>A(?:H|B(?&imp)C)|A(?:$ump)C)/;
@a=<>;
chomp @a;
print "SLURPYS OUTPUT\n";
shift @a;
while(@a){
$_=shift @a;
my $i;
if(/^$imp$ump$/){
$i="YES\n";
}else{
$i="NO\n";
}
push @R,$i;
}
print @R;
print "END OF OUTPUT\n";
재미없게 짰습니다. 많은 지적 부탁드립니다.
def isSlump(st):
if st[0] != 'D' and st[0] != 'E':
return False
i = 1
while st[i] == 'F':
i += 1
if i == 1:
return False
elif i == len(st)-1 and st[i] == 'G':
return True
else:
return isSlump(st[i:])
def isSlimp(st):
if st[0] != 'A':
return False
if len(st) == 2:
if st[1] == 'H':
return True
else:
return False
elif st[-1] == 'C':
if st[1] == 'B':
return isSlimp(st[2:-1])
else:
return isSlump(st[1:-1])
else:
return False
def isSlurpy(St):
ls = [x for x in St]
ls.reverse()
u = len(St)-''.join(ls).find('C')
if u == len(St):
return False
print isSlimp(St[:u]), isSlump(St[u:])
return isSlimp(St[:u]) and isSlump(St[u:])
numOfSt = input()
print "SLURPYS OUTPUT"
for i in range(numOfSt):
print isSlurpy(raw_input())
print "END OF OUTPUT"
public static final String patternString = "([DE]F+)+G";
Pattern pattern;
public SlumpNSlimp(){
pattern = Pattern.compile(patternString);
}
public boolean isSlump(String arg){
return pattern.matcher(arg).matches();
}
public boolean isSlimp(String arg){
if ("AH".equals(arg)) return true;
else if (arg.startsWith("AB") && arg.endsWith("C")) {
return isSlimp(arg.substring(2, arg.length()-1));
}
else if (arg.startsWith("A") && arg.endsWith("C")) {
return isSlump(arg.substring(1, arg.length()-1));
}
return false;
}
public boolean isSlurpy(String arg){
// [CH][DE] 가 있으면
// HD or HE or CD or CE
int hdIndex = arg.lastIndexOf("HD");
if (hdIndex != -1){
String slimpStr = arg.substring(0, hdIndex+1);
String slumpStr = arg.substring(hdIndex+1, arg.length());
if (isSlimp(slimpStr) && isSlump(slumpStr)){
return true;
}
}
int heIndex = arg.lastIndexOf("HE");
if (hdIndex != -1){
String slimpStr = arg.substring(0, heIndex+1);
String slumpStr = arg.substring(heIndex+1, arg.length());
if (isSlimp(slimpStr) && isSlump(slumpStr)){
return true;
}
}
int cdIndex = arg.lastIndexOf("CD");
if (cdIndex != -1){
String slimpStr = arg.substring(0, cdIndex+1);
String slumpStr = arg.substring(cdIndex+1, arg.length());
if (isSlimp(slimpStr) && isSlump(slumpStr)){
return true;
}
}
int ceIndex = arg.lastIndexOf("CE");
if (ceIndex != -1){
String slimpStr = arg.substring(0, ceIndex+1);
String slumpStr = arg.substring(ceIndex+1, arg.length());
if (isSlimp(slimpStr) && isSlump(slumpStr)){
return true;
}
}
return false;
}
public class Slurpy {
private static boolean isSlump(char[] chars, int start, int end) {
if (start == end) return false;
if (chars[start] != 'D' && chars[start] != 'E') return false;
boolean containsF = false;
for (int i = start + 1; i <= end; i++) {
if (chars[i] == 'F') containsF = true;
if (containsF) {
switch (chars[i]) {
case 'F':
continue;
case 'G':
return (i == end);
default:
return isSlump(chars, i, end);
}
} else {
return false;
}
}
return false;
}
private static boolean isSlimp(char[] chars, int start, int end) {
if (start == end) return false;
if (chars[start] != 'A') return false;
if (end == start + 1) return chars[start + 1] == 'H';
if (chars[end] != 'C') return false;
switch (chars[start + 1]) {
case 'B':
return isSlimp(chars, start + 2, end - 1);
default:
return isSlump(chars, start + 1, end - 1);
}
}
public static boolean isSlurpy(char[] chars) {
for (int i = 0; i < chars.length; i++) {
if (isSlimp(chars, 0, i) && isSlump(chars, i + 1, chars.length - 1)) return true;
}
return false;
}
public static boolean isSlump(char[] chars) {
return isSlump(chars, 0, chars.length - 1);
}
public static boolean isSlimp(char[] chars) {
return isSlimp(chars, 0, chars.length - 1);
}
}
python입니다. 아직 패턴을 쓸줄 몰라서 naive하게 구현했어요;
n = int(input("#: "))
strs = [input(str(n) + ": ") for n in range(0, n)]
def isSlump(line):
if ((line[0] != 'D') and (line[0] != 'E')) or (line[1] != 'F'): return -1
idx = 2
while (line[idx] == 'F'): idx = idx + 1
if line[idx] == 'G': return idx + 1
ret = isSlump(line[idx:])
if (ret < 0): return -1
return idx + ret
def isSlimp(line):
if line[0] != 'A': return -1
if line[1] == 'H': return 2
if line[1] == 'B':
ret = isSlimp(line[2:])
if (ret < 0) or (line[2 + ret] != 'C'): return -1
return ret + 3
ret = isSlump(line[1:])
if (ret < 0) or (line[1 + ret] != 'C'): return -1
return ret + 2
def isSlurpy(line):
ret = isSlimp(line)
if ret < 0: return False
return (isSlump(line[ret:]) > 0)
print("SLURPYS OTUPUT")
for cndt in strs:
if isSlurpy(cndt): print("YES")
else: print("NO")
print("END OF OUTPUT")
#include <iostream>
#include <regex>
using namespace std;
bool isSlump(const std::string& str)
{
std::regex rgx("^[DE]F+((.*)G)");
std::cmatch matches;
if (std::regex_match(str.c_str(), matches, rgx))
{
if (matches[2].str().empty())
return true; // 더이상 재귀로 들어갈 곳이 없다는건 스럼프가 맞다는 뜻.
else
return isSlump(matches[1]); // 재귀로 들어가서 스럼프인지 검사.
}
return false;
}
bool isSlimp(const std::string& str, int* pEndIdx = nullptr)
{
// AH일때는 바로 스림프인지 알 수 있으므로 특별히 분리해서 검사.
if (str.length() >= 2)
{
if (str[0] == 'A' && str[1] == 'H')
{
if (pEndIdx != nullptr)
*pEndIdx = 2;
return true;
}
}
std::regex rgx("^(A(.+)C).*");
std::cmatch matches;
if (std::regex_match(str.c_str(), matches, rgx))
{
if (pEndIdx != nullptr)
*pEndIdx = matches[1]/*(A(.+)C)*/.length();
// A 다음에 B가 오면 스림프가 이어서 오고 아니면 스럼프가 이어서 와야함.
if (matches[2]/*(.+)*/.str()[0] == 'B')
{
return isSlimp(matches[2].str().c_str() + 1);
}
else
{
return isSlump(matches[2]);
}
}
return false;
}
bool isSlurpy(const std::string& str)
{
// 스림프 다음에 스럼프가 오면 스러피이다.
int endSlimpIdx = 0;
if (isSlimp(str, &endSlimpIdx))
{
if (isSlump(str.c_str() + endSlimpIdx))
{
return true;
}
}
return false;
}
int main()
{
// 스러피인지 확인할 문자열들을 입력받습니다.
int strCnt = 0;
cin >> strCnt;
if (cin.fail() || strCnt < 1) return -1;
std::string* strList = new(nothrow) std::string[strCnt];
if (strList == nullptr) return -2;
for (int i = 0; i < strCnt; ++i)
{
cin >> strList[i];
}
// 스러피인지 확인해서 보여줍니다.
cout << "SLURPYS OUTPUT" << endl;
for (int i = 0; i < strCnt; ++i)
{
if (isSlurpy(strList[i]))
cout << "YES" << endl;
else
cout << "NO" << endl;
}
cout << "END OF OUTPUT" << endl;
delete[] strList;
strList = nullptr;
return 0;
}
C++에 정규식이 있기는 한데 재귀 정규식은 배운적이 없어서... (아니면 표준에 아예 없을수도?) 노가다 좀 했네요.
def isSlump(s):
if len(s)==0 : return False
s=list(s)
if not s.pop(0) in ['D','E'] : return False
if s.pop(0)!='F':return False
while len(s)>0 and s[0]=='F':s.pop(0)
if len(s)==1 and s[0]=='G':return True
else : return isSlump(s)
def isSlimp(s):
if len(s)==0 : return False
s=list(s)
if s==['A','H'] : return True
if s.pop(0)!='A':return False
if len(s)>0 and s[-1]=='C':
if isSlump(s[:-1]):return True
if s.pop(0)=='B' and isSlimp(s[:-1]) : return True
return False
def isSlurpy(s):
for i in range(1,len(s)):
if isSlimp(s[:i]) :
if isSlump(s[i:]) : return True
return False
words = []
n = input()
for i in range(n):
words.append(raw_input())
print
print "SLURPYS OUTPUT"
for w in words:
print "YES" if isSlurpy(w) else "NO"
print "END OF OUTPUT"
Haskell로 작성하였습니다.
import Text.Regex
import Text.Regex.Posix
import Control.Monad
-- REGULAR EXPRESSIONS
reSlump = makeRegex "([D|E]F+)+G"::Regex
reSlimp = makeRegex "AH|A([D|E]F+)+GC|AB(.+)C"::Regex
-- check functions
isMatched (Just (a,b,c,d)) = (a == "" && b /= "")
isMatched Nothing = False
isFullMatched (Just (a,b,c,d)) = (a == "" && b /= "" && c == "")
isFullMatched Nothing = False
getRecursiveSlimp (Just (a,b,c,d)) = if length d > 1 then d !! 1 else ""
getRecursiveSlimp Nothing = ""
restTestCase (Just (a,b,c,d)) = c
restTestCase Nothing = ""
-- test Slump, Slimp
test regex testCase = if matchedGroup /= "" then test regex matchedGroup else isMatched result
where
result = matchRegexAll regex testCase
matchedGroup = getRecursiveSlimp result
-- test Slurpy
testSlurpy testCase = if isSlimp then isSlump else False
where
resultSlimp = matchRegexAll reSlimp testCase
isSlimp = isMatched resultSlimp
isSlump = isFullMatched $ matchRegexAll reSlump (restTestCase resultSlimp)
main = do
-- main program
putStr "input test count : "
n <- getLine
testCases <- forM [1..(read n::Int)] $ \i -> getLine
-- result
putStrLn "-----------------------------------------------------"
putStrLn "SLURPYS OUTPUT"
mapM_ putStrLn $ map (\testCase -> if (testSlurpy testCase) then "YES" else "NO") testCases
putStrLn "END OF OUTPUT"
결과
input test count : 2
AHDFG
DFGAH
-----------------------------------------------------
SLURPYS OUTPUT
YES
NO
END OF OUTPUT
import re
sample_input = '''DFG, EFG, DFFFFFG, DFDFDFDFG, DFEFFFFFG, DFEFF, EFAHG, DEFG, DG, EFFFFDG,AH, ABAHC, ABABAHCC, ADFGC, ADFFFFGC, ABAEFGCC, ADFDFGC,ABC, ABAH, DFGC, ABABAHC, SLIMP, ADGC,AHDFG, ADFGCDFFFFFG, ABAEFGCCDFEFFFFFG,AHDFGA, DFGAH, ABABCC'''
def isSlump(s):
if re.match('([DE]F+)+G$', s):return 1
def isSlimp(s):
if re.match('AH$', s):return 1
if re.match('(AB)+AHC+$', s) and len(re.findall('AB',s)) == len(re.findall('C', s)): return 1
if re.match('(AB)+(A([DE]F+)+GC)C+$', s): return 1
if re.match('A([DE]F+)+GC$', s):return 1
def isSlurpy(s):
for i in range(len(s)):
if s[-i-1] == 'C' or s[-i-1] == 'H':
front = s[:len(s)-i]
back = s[len(s)-i:]
return (isSlimp(front) == 1) and (isSlump(back) == 1)
return (isSlump(s) == 1) and (isSlimp(s) == 1)
while __name__ == '__main__':
turn = int(input("입력: ").strip())
t = []
for i in range(turn):
t.append(input("{0} :".format(i+1)))
for i in range(len(t)):
t[i] = t[i].strip()
t = list(map (isSlurpy, t))
print ("SLURPYS OUTPUT")
for num in t:
if num == True:print("YES")
else:print("NO")
print ("END OF OUTPUT")
정규식 사용했습니다. 파이썬 3.5.1
정규식으로 슬림프, 슬럼프를 판별하는 함수를 각각 만들고, 다시 정규식패턴으로 슬럼프|슬림프 조합인 단어를 찾아 각각의 조각이 슬럼프/슬림프인지 확인했습니다. 파이썬 정규식은 재귀패턴을 지원하지 않는데, 슬림프의 경우에는 재귀호출을 하지 않는 형태로 작성하였습니다.
import re
def is_slump(s):
if not s:
return False
pat = re.compile(r'^(?:D|E)F+(.*(?:G))$')
while s:
d = pat.findall(s)
if not d:
return False
s = d[0]
if s == 'G':
return True
return False
udata = 'DFG EFG DFFFFFG DFDFDFDFG DFEFFFFFG DEFEFF EFAHG DEFG DG EFFFFDG'.split()
# for u in udata:
# print(u, is_slump(u))
def is_slimp(s):
if not s:
return False
pat = re.compile(r'^(?:A)(?:(?:H$)|(?:(?:B(.*))|(.*))(?=C$))')
while s:
d = pat.findall(s)
if not d:
return False
a, b = d[0]
if a:
s = a
continue
if b:
return is_slump(b)
return True
return False
sdata = 'AH ABAHC ABABAHCC ADFGC ADFFFFGC ABAEFGCC \
ADFDFGC ABC ABAH DFGC ABABAHC SLIMP ADGV'.split()
# for s in sdata:
# print(s, is_slimp(s))
def is_slupy(s):
pat = re.compile(r'^(?:(A.*C)|(?:(AH)))(.*)$')
d = pat.findall(s)
if not d:
return False
d = d[0]
return (is_slimp(d[0]) or is_slimp(d[1])) and is_slump(d[2])
slurpies = '''AHDFG ADFGCDFFFFG ABAEFGCCDFEFFFFFG AHDFGA DFGAH ABABCC'''.split()
for i in slurpies:
print(i, is_slupy(i))
파이썬 3.4.2 어떠한 모듈도 불러오지 않았습니다.
def slump(s):
try:
boo1 = (s[0] in ['D','E'])
s = s[1:]
c = 0
while s[0] == 'F':
c += 1
s = s[1:]
boo2 = (c > 0)
boo3 = (s == 'G' or slump(s))
except IndexError:
i = False
else:
i = boo1 and boo2 and boo3
if i:
return True
else:
return False
def slimp(s):
try:
boo1 = (s[0] == 'A')
if len(s) == 2:
boo2 = (s[1] == 'H')
boo3 = True
else:
boo2 = (s[len(s)-1] == 'C')
s = s[1:len(s)-1]
if slump(s):
boo3 = True
else:
if s[0] == 'B' and slimp(s[1:]):
boo3 = True
else:
boo3 = False
except IndexError:
i = False
else:
i = boo1 and boo2 and boo3
if i:
return True
else:
return False
def slumpy(s):
res = False
for i in range(len(s)):
s1 = s[:i]
s2 = s[i:]
res = (res or (slimp(s1) and slump(s2)))
return res
dir = {True:'YES',False:'NO'}
que = []
########################################################################################################################
n = int(input())
for i in range(n):
que.append(input())
print('SLURPYS OUTPUT')
for i in que:
print(dir[slumpy(i)])
print('END OF OUTPUT')
def slump(a):
b=0
if a[0]=="D" or a[0]=="E":
if "F" in a[1:]:
for i in a:
if i=="F":
b=a.index(i)
if slump(a[b:]) or "G"==a[-1]:
return 1
else:
return 0
else:
return 0
else:
return 0
def slimp(a):
if a[0]=="A":
if len(a)==2 and a[1]=="H":
return 1
elif a[1]=="B" and slimp(a[2:-1]) and a[-1]=="C":
return 1
elif slump(a[1:-1]) and a[-1]=="C":
return 1
else:
return 0
else:
return 0
def slurpy(a):
if a[0:2]=="AH":
if slump(a[2:]):
return 1
else:
if "C" in a:
b=a.index("C")
c=a.count("C")
if a[b+c-1]=="C":
if slimp(a[:b+c]) and slump(a[b+c:]):
return 1
else:
return 0
else:
return 0
else:
return 0
a=input()
b=[]
for i in range(int(a)):
b.append(input())
print("SLURPYS OUTPUT")
for i in b:
if slurpy(i):
print("YES")
else:
print("NO")
print("END OF OUTPUT")
정규식 배워야 겠다는 생각만 드네요.
Ruby
slump = /([DE]F+)+G/
slimp = /(?<slimp>AH|AB\g<slimp>C|A#{slump}C)/
slurpy = /#{slimp}#{slump}/
chks = proc { (1..(gets.to_i)).map { gets.chop=~/^#{slurpy}$/ ? "YES":"NO"} }
out_slurpy_chks = proc { puts "SLURPY OUTPUT", chks[], "END OF OUTPUT"}
Test
slumps = %w(DFG EFG DFFFFFG DFDFDFDFG DFEFFFFFG)
not_slumps = %w(DFEFF EFAHG DEFG DG EFFFFDG)
slimps = %w(AH ABAHC ABABAHCC ADFGC ADFFFFGC ABAEFGCC ADFDFGC)
not_slimps = %w(ABC ABAH DFGC ABABAHC SLIMP ADGC)
slurpys = %w(AHDFG ADFGCDFFFFFG ABAEFGCCDFEFFFFFG)
not_slurpys= %w(AHDFGA DFGAH ABABCC)
#=> regex test
expect( slumps.all? {|s| s=~/^#{slump}$/ } ).to eq true
expect( not_slumps.all? {|s| s=~/^#{slump}$/ } ).to eq false
expect( slimps.all? {|s| s=~/^#{slimp}$/} ).to eq true
expect( not_slimps.all? {|s| s=~/^#{slimp}$/ } ).to eq false
expect( slurpys.all? {|s| s=~/^#{slurpy}$/ } ).to eq true
expect( not_slurpys.all? {|s| s=~/^#{slurpy}$/ } ).to eq false
Output
#=>out_slurpy_chks[]
4
AHDFG
ADFGCDFFFFFG
ABAEFGCCDFEFFFFFG
DFGAH
SLURPY OUTPUT
YES
YES
YES
NO
END OF OUTPUT
package h_slurpy;
public class Check {
int i,j;
boolean slump(String S, int a, int b){
if(S.charAt(a)=='D'||S.charAt(a)=='E'){ //첫글자는 D,E
for(i=a+1;i
boolean slimp(String S, int a, int b){
if(S.charAt(a)=='A'){ //첫글자는 A
if(a+2==b && S.charAt(a+1)=='H') return true; //두글자 AH
else if(S.charAt(a+1)=='B' && S.charAt(b-1)=='C' && slimp(S, a+2, b-1)) return true;
else if(S.charAt(b-1)=='C' && slump(S, a+1, b-1)) return true;
else return false;
} else return false;
}
boolean slurpy(String S){
int l=S.length(); int d;
for(i=l-1;i>=0;i--) if(S.charAt(i)=='C'||S.charAt(i)=='H') break;
if(i<0) return false;
else{
d=i+1;
if( slimp(S, 0, d) && slump(S, d, l) ) return true;
else return false;
}
}
}
package h_slurpy;
import java.util.Scanner;
public class Slurpy {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
Check C=new Check();
int N, i;
N=in.nextInt();
while(!(N>0&&N<=10)){ System.out.print("N:1~10의 정수. 다시입력해주세요"); N=in.nextInt();}
String[] input=new String[N];
for(i=0;i<N;i++) input[i]=in.next(); //input[i]는 1~60개의 알파벳문자
System.out.println("SLURPYS OUTPUT");
for(i=0;i<N;i++){
if(C.slurpy(input[i])) System.out.println("YES");
else System.out.println("NO");
}
System.out.println("END OF OUTPUT");
}
}
static final String slimpRegex = "^AH|((AB|A)(.*)C)$";
static final String slumpRegex = "^[D|E]F+([D|E]F+G*)*G$";
static final String slupyRegex = "^(AH|((AB|A)(.*)C))([D|E]F+([D|E]F+G*)*G)$";
public static void main(String[] args) {
List<String> in = Lists.newArrayList();
Scanner scanner = new Scanner(System.in);
boolean flag;
String input;
int line = 0;
do {
input = scanner.nextLine();
try {
Assert.isTrue(0 < Integer.valueOf(input));
Assert.isTrue(10 >= Integer.valueOf(input));
flag = false;
line = Integer.valueOf(input);
} catch (IllegalArgumentException e) {
System.out.println("1~10 사이의 수를 입력하세요");
flag = true;
}
} while(flag);
System.out.println("");
for(int i=0;i<line;i++) {
do {
input = scanner.nextLine();
try {
Assert.isTrue(input.length() > 0);
Assert.isTrue(input.length() <= 60);
flag = false;
} catch (IllegalArgumentException e) {
System.out.println("문자열은 1~60 자리입니다.");
flag = true;
}
} while(flag);
in.add(scanner.nextLine());
}
System.out.println("SLURPYS OUTPUT");
for(String str : in) {
System.out.println(isMatch(slupyRegex, str) ? "YES" : "NO");
}
System.out.println("END OF OUTPUT");
scanner.close();
}
private static boolean isMatch(String regex, String str) {
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(str);
if ( matcher.matches() && regex.equals(slimpRegex) && matcher.group(3) != null ) {
return matcher.group(2).equals("A") ? isMatch(slumpRegex, matcher.group(3)) : isMatch(slimpRegex, matcher.group(3));
}
return matcher.matches();
}
package main
import (
"fmt"
)
func Slump(s []rune) (bool, int) {
i := 0
if s[i] != 'D' && s[i] != 'E' {
return false, 0
}
i++
F := false
for s[i] == 'F' {
i++
F = true
}
if F == false {
return false, 0
}
if s[i] == 'G' {
return true, i+1
} else {
ok, size := Slump(s[i:])
return ok, i+size
}
}
func Slimp(s []rune) (bool, int) {
i := 0
if s[i] != 'A' {
return false, 0
}
if s[i+1] == 'H' {
i++
return true, i+1
}
i++
if s[i] == 'B' {
i++
ok, size := Slimp(s[i:])
if ok == false {
return false, 0
}
i += size
if s[i] == 'C' {
return true, i + 1
} else {
return false, 0
}
}
ok, size := Slump(s[i:])
if ok == false {
return false, 0
}
i += size
if s[i] == 'C' {
return true, i + 1
} else {
return false, 0
}
}
func Slurpy(s []rune) bool {
i := 0
ok, size := Slimp(s)
i += size
if ok {
ok, size := Slump(s[size:])
i += size
if ok && i == len(s) {
return true
}
}
return false
}
func TestSlurpy(str string) (result bool) {
defer func() {
if r := recover(); r != nil {
result = false
}
}()
s := []rune{}
for _, r := range (str) {
s = append(s, r)
}
return Slurpy(s)
}
func main() {
var n int
var s string
ss := []string{}
fmt.Scan(&n)
for i := 0; i < n; i++ {
fmt.Scan(&s)
ss = append(ss, s)
}
fmt.Println("SLURPYS OUTPUT")
for i := 0; i < n; i++ {
s := "NO"
if TestSlurpy(ss[i]) {
s = "YES"
}
fmt.Println(s)
}
fmt.Println("END OF OUTPUT")
}
#include <iostream>
#include <regex>
#include <vector>
#include <string>
unsigned int slump(std::string data);
unsigned int slimp(std::string data);
unsigned int slurpy(std::string& data);
int main(void) {
int num, i;
std::string data2;
std::vector<std::string> data1;
std::cin >> num;
for (i = 0; i < num; i++) {
std::cin >> data2;
data1.push_back(data2);
}
std::cout << "SLURPYS OUTPUT" << std::endl;
for (auto dt : data1) {
if (slurpy(dt))
std::cout << "YES" << std::endl;
else
std::cout << "NO" << std::endl;
}
std::cout << "END OF OUTPUT" << std::endl;
return 0;
}
unsigned int slump(std::string data) {
std::regex rgx("^[DE]F+((.*)G)");
std::cmatch mchs;
if (std::regex_match(data.c_str(), mchs, rgx)) {
if (!(mchs[2].str().empty())) {
return slump(mchs[1]);
}
else {
return 1;
}
}
return 0;
}
unsigned int slimp(std::string data) {
std::regex rgx_for_first("(AB(.+)C)");
std::regex rgx_for_second("(A(.+)C)");
std::cmatch mchs;
if (data.c_str()[0] == 'A' && data.c_str()[1] == 'H') return 1;
if (std::regex_match(data.c_str(), mchs, rgx_for_first)) {
if (!(mchs[2].str().empty())) {
if (slimp(mchs[2]))
return 1;
else
return 0;
}
}
else if (std::regex_match(data.c_str(), mchs, rgx_for_second)) {
if (!(mchs[2].str().empty())) {
if (slump(mchs[2]))
return 1;
else
return 0;
}
}
return 0;
}
unsigned int slurpy(std::string& data) {
std::regex rgx_first("(AB(.+)C)");
std::regex rgx_second("(A(.+)C)");
std::smatch match;
if (data.c_str()[0] == 'A' && data.c_str()[1] == 'H') {
if (slump(data.c_str() + 2)) {
return 1;
}
}
else if (std::regex_search(data, match, rgx_first)) {
if (slimp(match[1])) {
if (slump(data.c_str() + match[1].length())) {
return 1;
}
}
}
else if (std::regex_search(data, match, rgx_second)) {
if (slimp(match[1])) {
if (slump(data.c_str() + match[1].length())) {
return 1;
}
}
}
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
bool slump(char* str);
bool slimp(char* str);
void main(void) {
int n = 1;
char** val;
scanf("%d",&n);
val = (char**) malloc (sizeof(char*) * n);
for(int i = 0 ; i < n ;i++) {
val[i] = (char*) malloc (sizeof(char*) * 60);
}
for(int i = 0 ; i < n ; i++)
scanf("%s", val[i]);
printf("\nSLURPYS OUTPUT\n");
for(int count = 0; count < n; count ++) {
bool execute = false;
int length = strlen(val[count]);
char* str_slimp = (char*) malloc (sizeof(char)* length);
char* str_slump = (char*) malloc (sizeof(char)* length);
int temp = 0;
for(int i = 0 ; i < length; i++) {
if(val[count][i] == 'C' || val[count][i] == 'H') {
temp = (i+1);
execute = true;
}
}
if(execute == true) {
str_slimp = (char*) malloc (sizeof(char)* temp);
for(int i = 0 ; i < temp; i++) {
str_slimp[i] = val[count][i];
}
str_slimp[temp] = NULL;
str_slump = (char*) malloc (sizeof(char)* (length-temp));
int j = 0;
for(int i = temp; i < length; i++) {
str_slump[j] = val[count][i];
j++;
}
str_slump[length-temp] = NULL;
}
if(slump(str_slump) == true && slimp(str_slimp) == true && execute == true) {
printf("YES\n");
}
else
printf("NO\n");
}
printf("END OF OUTPUT\n");
}
bool slimp(char* str) {
int length = 0;
length = strlen(str);
char* temp = (char*) malloc (sizeof(char)*(length-1));
for(int i = 0 ; i < (length-1) ; i++) {
temp[i] = str[i];
}
temp[(length-1)] = NULL;
if(str[0] == 'A') {
}
else
return false;
if(length == 2) {
if(str[1] == 'H') {
}
else
return false;
}
else if(str[1] == 'B' ) {
if(slimp(temp+2) == true) {
if(str[length-1] == 'C') {
}
else
return false;
}
else
return false;
}
else if(slump(temp+1) == true) {
if(str[length-1] == 'C') {
}
else
return false;
}
else
return false;
return true;
}
bool slump(char* str) {
int length = strlen(str);
int temp = 1;
if(str[0] == 'D' || str[0] =='E') {
}
else
return false;
for(int i = 1 ; i < length ;i++) {
if(str[1] = 'F') {
}
else
return false;
if(str[i] == 'D' || str[i] =='E' || str[i] == 'G')
break;
if(str[i] == 'F') {
temp++;
}
else
return false;
}
if(str[length-1] == 'G') {
}
else {
if(true == slump(str+temp)) {
}
else
return false;
}
return true;
}
#include <stdio.h>
enum bool { false, true };
enum {
A, H_B_D_E, C,
D_E, F, F_, G_D_E,
ERR, OK
};
int trySlump(char* s, char** p){ //([D|E]F+)+G
int sts = D_E;
while(*s != '\0' && sts != ERR && sts != OK){
switch(sts){
case D_E:
if(*s == 'D' || *s == 'E') { sts = F; s++; } else { sts = ERR; } break;
case F:
if(*s == 'F') { sts = F_; s++; } else { sts = ERR; } break;
case F_:
if(*s == 'F') { s++; } else { sts = G_D_E; } break;
case G_D_E:
if(*s == 'G') { sts = OK; } else { sts = D_E; } break;
default:
sts = ERR; break;
}
}
*p = s;
if(sts == OK) {
return true;
} else {
return false;
}
}
int trySlimp(char* s, char** p){ //A[H|B<slimp>C|<slump>C]
int sts = A;
while(*s != '\0' && sts != ERR && sts != OK){
switch(sts){
case A:
if(*s == 'A') { sts = H_B_D_E; s++; } else { sts = ERR; } break;
case H_B_D_E:
if(*s == 'H') { sts = OK; break; }
if(*s == 'B') {
s++;
if(trySlimp(s, &s)){
s++; sts = C;
}else{
sts = ERR;
}
break;
}
if(*s == 'D' || *s == 'E') {
if(trySlump(s, &s)){
s++; sts = C;
}else{
sts = ERR;
}
break;
}
sts = ERR;
break;
case C:
if(*s == 'C') { sts = OK; } else { sts = ERR; } break;
default:
sts = ERR; break;
}
}
*p = s;
if(sts == OK) {
return true;
} else {
return false;
}
}
int trySlurpy(char* s, char** p){ //<slimp><slump>
if(trySlimp(s, &s)){
s++;
if(trySlump(s, &s)){
*p = s;
return OK;
}
return ERR;
}else{
*p = s;
return ERR;
}
}
int main()
{
char* slumps[10] = { "DFG", "EFG", "DFFFFFG", "DFDFDFDFG", "DFEFFFFFG",
"DFEFF", "EFAHG", "DEFG", "DG", "EFFFFDG" };
printf("\n==SLUMP TEST==\n");
for(int i = 0; i < 10; i++){
printf("%s : ", slumps[i]);
if(trySlump(slumps[i], &slumps[i]) && *++slumps[i] == '\0') {
printf("YES\n");
} else {
printf("NO\n");
}
}
char* slimps[13] = { "AH", "ABAHC", "ABABAHCC", "ADFGC", "ADFFFFGC",
"ABAEFGCC", "ADFDFGC", "ABC", "ABAH", "DFGC", "ABABAHC", "SLIMP", "ADGC" };
printf("\n==SLIMP TEST==\n");
for(int i = 0; i < 13; i++){
printf("%s : ", slimps[i]);
if(trySlimp(slimps[i], &slimps[i]) && *++slimps[i] == '\0') {
printf("YES\n", slimps[1]);
} else {
printf("NO\n");
}
}
char* slurpys[8] = { "AHDFG", "ADFGCDFFFFFG", "ABAEFGCCDFEFFFFFG",
"AHDFGA", "DFGAH", "ABABCC",
"AHDFG", "DFGAH" };
printf("\n==SLURPY TEST==\n");
for(int i = 0; i < 8; i++){
printf("%s : ", slurpys[i]);
if(trySlurpy(slurpys[i], &slurpys[i]) && *++slurpys[i] == '\0') {
printf("YES\n", slurpys[1]);
} else {
printf("NO\n");
}
}
}
D:\16.minGW>gcc a.c
D:\16.minGW>a
==SLUMP TEST==
DFG : YES
EFG : YES
DFFFFFG : YES
DFDFDFDFG : YES
DFEFFFFFG : YES
DFEFF : NO
EFAHG : NO
DEFG : NO
DG : NO
EFFFFDG : NO
==SLIMP TEST==
AH : YES
ABAHC : YES
ABABAHCC : YES
ADFGC : YES
ADFFFFGC : YES
ABAEFGCC : YES
ADFDFGC : YES
ABC : NO
ABAH : NO
DFGC : NO
ABABAHC : NO
SLIMP : NO
ADGC : NO
==SLURPY TEST==
AHDFG : YES
ADFGCDFFFFFG : YES
ABAEFGCCDFEFFFFFG : YES
AHDFGA : NO
DFGAH : NO
ABABCC : NO
AHDFG : YES
DFGAH : NO
D:\16.minGW>
def isSlump(s, before_count = 0):
flag = False
count = 0
str_checker = False
try :
if s[count] in ['D','E'] :
count += 1
if s[count] is 'F' :
while s[count] is 'F' :
count += 1
if s[count] is 'G' and len(s)-1 == count:
# if s[count] is 'G' :
flag = True
else :
str_checker, count = isSlump(s[count:], count)
if str_checker is True :
flag = True
except IndexError :
count -= 1
pass
finally :
if flag is True :
return flag, count + before_count
else :
return flag, before_count
def isSlimp(s, before_count = 0):
flag = False
count = 0
str_checker = False
try :
if s[count] is 'A' :
count += 1
if s[count] is 'H' :
flag = True
else :
if s[count] is 'B' :
count += 1
str_checker, count = isSlimp(s[count:-1], count)
else :
str_checker, count = isSlump(s[count:-1], count)
if str_checker is True :
count += 1
if s[count] is 'C' :
flag = True
except IndexError :
count -= 1
pass
finally :
return flag, count + before_count
def isSlurpy(s):
count = 0
flag = False
str_checker = False
for i in range(len(s)):
str_checker, count = isSlimp(s[:i],count)
if str_checker is True :
str_checker, count = isSlump(s[i:],count)
if str_checker is True :
flag = True
return flag
lines = []
result = ''
num = int(input())
for i in range(num) :
line = input()
while len(line) is 0 or len(line) > 61 :
print("0<line<60")
line = input()
lines.append(line)
print ("SLURPYS OUTPUT")
for i in range(num) :
if isSlurpy(lines[i]) :
result = "YES"
else :
result = "NO"
print (result)
print ("END OF OUTPUT")
어우 힘들게 풀었어요 정규식으로는 상당히 짧게 가능하네요
#include <stdio.h>
int main(void)
{
int testCase;
int i = 0;
int j = 0;
int k = 0;
int l = 0;
int count = 0;
char string[1024];
int slimpyEndPoint = 0;
int lengthSize = 0;
printf("SLURPYS OUTPUT\n");
scanf_s("%d", &testCase);
for (k = 0; k < testCase; k++)
{
scanf_s("%s", string, sizeof(string));
for (lengthSize = 0 ; string[lengthSize] != '\0'; lengthSize++)
{
}
lengthSize--;
slimpyEndPoint = lengthSize;
while (string[slimpyEndPoint] != 'C' && string[slimpyEndPoint] != 'H')
{
slimpyEndPoint--;
if (slimpyEndPoint < 0)
{
printf("NO\n");
}
}
i = 0;
while (1)
{
if (string[i] == 'A')
{
string[i] = 1;
i++;
if (string[i] == 'B')
{
string[i] = 1;
i++;
if (string[slimpyEndPoint] == 'C')
{
string[slimpyEndPoint] = 1;
slimpyEndPoint--;
}
}
else if (string[i] == 'D' || string[i] == 'E')
{
while (string[i] == 'D' || string[i] == 'E')
{
string[i] = 1;
if (string[i + 1] == 'F')
{
string[i + 1] = 1;
i += 2;
}
}
while (string[i] == 'F')
{
string[i] = 1;
i++;
}
if (string[i] == 'G')
{
string[i] = 1;
i++;
if (string[i] == 'C')
{
string[i] = 1;
i++;
}
}
}
else if (string[i] == 'H')
{
string[i] = 1;
i++;
break;
}
}
else
{
break;
}
}
i = lengthSize;
if (string[i] == 'G')
{
string[i] = 1;
i--;
while (string[i] == 'F')
{
string[i] = 1;
i--;
}
if (string[i] == 'D' || string[i] == 'E')
{
string[i] = 1;
i--;
}
while ((string[i - 1] == 'D' || string[i - 1] == 'E') && (string[i] == 'F'))
{
string[i - 1] = string[i] = 1;
i = i - 2;
}
}
for (i = 0; i <= lengthSize; i++)
{
if (string[i] != 1)
{
printf("NO\n");
break;
}
}
for (i = 0, count = 0; i <= lengthSize; i++)
{
if (string[i] == 1)
{
count++;
}
if (count >= lengthSize)
{
printf("YES\n");
break;
}
}
}
printf("END OF OUTPUT\n");
return 0;
}
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'
[정규식]
import regex
slump = "(?P<slump>[DE]F+((?&slump)|G))"
slimp = "(?P<slimp>A(H|B(?&slimp)C|(?&slump)C))"
slurpy = f"^{slimp}{slump}$"
inp = "2\nAHDFG\nDFGAH"
print("SLURPY OUTPUT")
for s in inp.splitlines()[1:]:
print('YES' if regex.match(slurpy, s) else 'NO')
print("END OF OUTPUT")
public class Slurpy {
public static void main(String[] args) {
int n = new Scanner(System.in).nextInt();
String[] list = new String[n];
for(int i = 0; i < n; i++){
list[i] = new Scanner(System.in).nextLine();
}
solution(list);
}
public static void solution(String[] list){
System.out.println("\nSLURPYS OUTPUT");
for (int i = 0; i < list.length; i++) {
System.out.println(isSlurpy(list[i]) ? "YES" : "NO");
}
System.out.println("END OF OUTPUT");
}
public static boolean isSlurpy(String str) {
boolean checkSlumps = false;
boolean checkSlimps = false;
int cut = str.lastIndexOf('C') + 1;
if (cut == 0)
cut = str.lastIndexOf('H') + 1;
checkSlumps = isSlumps(str.substring(cut));
checkSlimps = isSlimps(str.substring(0, cut));
return (checkSlumps && checkSlimps) ? true : false;
}
private static boolean isSlumps(String str) {
if (str.charAt(0) == 'D' || str.charAt(0) == 'E') {
for (int i = 1; i < str.length(); i++) {
if (i == str.length() - 1 && str.charAt(i) == 'G')
return true;
else if (str.charAt(i) != 'F')
return isSlumps(str.substring(i)) ? true : false;
}
}
return false;
}
private static boolean isSlimps(String str) {
if (str.charAt(0) == 'A') {
if (str.length() == 2 && str.equals("AH")) return true;
else if (str.charAt(str.length() - 1) == 'C') {
for (int i = 1; i < str.length() - 1; i++) {
if (str.charAt(i) == 'B')
return isSlimps(str.substring(i + 1, str.length() - 1)) ? true : false;
else
return isSlumps(str.substring(i, str.indexOf('G') + 1)) ? true : false;
}
}
}
return false;
}
}
import java.util.Scanner;
public class Main {
public static boolean isSlurpy(String word){
int length = word.length();
return sp(word,0,length-1);
}
public static boolean sp(String word, int l, int u){
if(word.charAt(l)!='A') return false;
else{
if(word.charAt(l+1)=='H') return isSlump(word.substring(l+2));
else{
int j=-1;
for(int i=l; i<u; i++){
if(word.charAt(i)=='C')j= i;
}
if(j==-1) return false;
else return isSlimp(word.substring(l, j+1))&&isSlump(word.substring(j+1));
}
}
}
public static boolean isSlimp(String word){
int length = word.length();
return sl(word,0,length-1);
}
public static boolean sl(String word, int l, int u){
if(u-l+1<2) return false;
if((word.charAt(l)!='A')) return false;
else{
if(u-l+1==2) return word.charAt(u)=='H';
else{
boolean temp;
if(word.charAt(l+1)=='B') temp = sl(word,l+2,u-1);
else temp = sh(word,l+1,u-1);
return (word.charAt(u)=='C')&&temp;
}
}
}
public static boolean isSlump(String word){
int length = word.length();
return sh(word,0,length-1);
}
public static boolean sh(String word, int l, int u){
if( ((word.charAt(l)!='D')&&(word.charAt(l)!='E'))||word.charAt(u)!='G'||word.charAt(l+1)!='F') return false;
else{
if(u-l+1>2){
int i;
for(i=l+1; i<u; i++){
if(word.charAt(i)!='F') break;
else{
if(i+1<=u&&word.charAt(i+1)=='G'){
if(i+1==u) return true;
else return sh(word,i+2,u);
}
}
}
return sh(word,i,u);
}
return false;
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt(); String[] words = new String[n];
for(int i=0; i<n; i++){
words[i] = sc.next().toUpperCase();
}
System.out.println("SLURPYS OUTPUT");
for(int i=0; i<n; i++){
if(isSlurpy(words[i])) System.out.println("YES");
else System.out.println("NO");
}
sc.close();
}
}
파이썬 3.6
def inputdata():
N = int(input("N = "))
data = [input('') for i in range(N)]
return data
def isSlimp(s):
if len(s) == 2 and s[0] == 'A' and s[1] == 'H':
return True
elif s[0] == 'A':
if s[1] == 'B' and s[-1] == 'C':
if len(s[2:len(s)-1]) >= 2 and isSlimp(s[2:len(s)-1]):
return True
else:
return False
elif s[-1] == 'C':
if len(s[1:len(s)-1]) >= 2 and isSlump(s[1:len(s)-1]):
return True
else:
return False
else:
return False
else:
return False
def isSlump(s):
f = 0
if s[0] == 'D' or s[0] == 'E':
if s[1] == 'F' and s[-1] == 'G':
for i in s[1:]:
if i != 'F':
break
else:
f += 1
if 1+f > len(s)-1:
return False
elif s[1+f] == 'G':
return True
elif s[1+f] == 'D' or s[1+f] == 'E':
if isSlump(s[(1+f):]):
return True
else:
return False
else:
return False
else:
return False
else:
return False
def isSlurpy(s):
s_1,s_2 = '',''
if s[0] == 'A':
for i,value in enumerate(s[1:]):
if i == 0 and value == 'H':
s_1 = s[:2]
s_2 = s[2:]
break
elif i > 3:
if value == 'D' or value == 'E':
s_1 = s[:i+1]
s_2 = s[1:][i:]
break
if s_1 == '' and s_2 == '':
print("NO")
return
if isSlimp(s_1) and isSlump(s_2):
print("YES")
else:
print("NO")
else:
print("NO")
if __name__ == "__main__":
data = inputdata()
print("\n""SLURPYS OUTPUT")
N = 6
AHDFG
ADFGCDFFFFFG
ABAEFGCCDFEFFFFFG
AHDFGA
DFGAH
ABABCC
SLURPYS OUTPUT
YES
YES
YES
NO
NO
NO
END OF OUTPUT
def Slump(string):
if len(string)<3: return False
if string[0]!='D' and string[0]!='E' or string[1]!='F' or string[len(string)-1]!='G': return False
for i in range(2,len(string)):
if string[i]=='F': continue
elif string[i]=='D' or string[i]=='E':
if Slump(string[i:len(string)]): return True
else: return False
elif string[i]=='G': return True
else: return False
def Slimp(string):
if len(string)<2 or string[0]!='A': return False
if len(string)==2:
if string[1]=='H': return True
else:
if string[1]=='B' and Slimp(string[2:len(string)-1]) and string[len(string)-1]=='C': return True
elif Slump(string[1:len(string)-1]) and string[len(string)-1]=='C': return True
else: return False
count=int(input())
result=[]
while count!=0:
string=input()
if string.find('H')!=-1:
if Slimp(string[0:string.rfind('H')+1]) and Slump(string[string.rfind('H')+1:len(string)]): result.append("YES")
else: result.append("NO")
elif string.find('C')!=-1:
if Slimp(string[0:string.rfind('C')+1]) and Slump(string[string.rfind('C')+1:len(string)]): result.append("YES")
else: result.append("NO")
else: result.append("NO")
count-=1
print("SLURPYS OUTPUT")
for i in result: print(i)
print("END OF OUTPUT")
코드가 많이 더럽습니다 점차 수정중입니다!
def slurpy(a):
if a.count('C') == 0:
if a.count('H') == 0:
return 'NO'
else:
index = a.index('H')+1
else:
index = len(a) - a[::-1].index('C')
b = (a[:index], a[index:])
if slimp(b[0]) and slump(b[1]):
return 'YES'
else:
return 'NO'
def slimp(a):
if len(a) < 2:
return False
if a == 'AH':
return True
elif a[:2] == 'AB' and a[-1] == 'C' and slimp(a[2:-1]):
return True
elif a[0] == 'A' and a[-1] == 'C' and slump(a[1:-1]):
return True
else:
return False
def slump(a):
if len(a) < 3:
return False
elif a[-1] != 'G':
return False
else:
a = a.replace('E', 'D')[:-1].split('D')
if a[0] == '' and all([i == 'F'*len(i) for i in a[1:]]) and all(len(i) for i in a[1:]):
return True
else:
return False
import java.util.Scanner;
public class Slurpy {
public static boolean isSlurpy(String verb){
int isSlurpyIndex = 0;
verb = verb.toLowerCase();
for(isSlurpyIndex=0; isSlurpyIndex < verb.length(); isSlurpyIndex++){
String isSlimpVerb = verb.substring(0, isSlurpyIndex);
String isSlumpVerb = verb.substring(isSlurpyIndex, verb.length());
if(isSlimp(isSlimpVerb) && isSlump(isSlumpVerb)){
return true;
}else{
continue;
}
}
return false;
}
public static boolean isSlump(String verb){
int isSlumpIndex = 0;
verb = verb.toLowerCase();
try{
if(verb.substring(isSlumpIndex,isSlumpIndex+1).equals("d")){
isSlumpIndex++;
}else if(verb.substring(isSlumpIndex,isSlumpIndex+1).equals("e")){
isSlumpIndex++;
}else{
return false;
}
if(!verb.substring(isSlumpIndex, isSlumpIndex+1).equals("f")){
return false;
}else{
isSlumpIndex++;
boolean isF = true;
while(isF){
if(!verb.substring(isSlumpIndex,isSlumpIndex+1).equals("f")){
isF = false;
}else{
isSlumpIndex++;
}
}
isF = false;
if(verb.substring(isSlumpIndex,isSlumpIndex+1).equals("g") && verb.length() == isSlumpIndex+1){
return true;
}else{
if(isSlump(verb.substring(isSlumpIndex))){
return true;
}else{
return false;
}
}
}
}catch(StringIndexOutOfBoundsException e){
return false;
}
}
public static boolean isSlimp(String verb){
int isSlimpIndex = 0;
verb = verb.toLowerCase();
try{
if(verb.substring(isSlimpIndex,isSlimpIndex+1).equals("a")){
isSlimpIndex++;
}else{
return false;
}
if(verb.length() == 2 && verb.substring(isSlimpIndex,isSlimpIndex+1).equals("h")){
return true;
}
if(verb.substring(isSlimpIndex, isSlimpIndex+1).equals("b")){
isSlimpIndex++;
if(isSlimp(verb.substring(isSlimpIndex, verb.length()-1))){
if(verb.substring(verb.length()-1,verb.length()).equals("c")){
return true;
}else{
return false;
}
}else{
return false;
}
}
if(isSlump(verb.substring(isSlimpIndex,verb.length()-1)) && verb.substring(verb.length()-1,verb.length()).equals("c")){
return true;
}else{
return false;
}
}catch(StringIndexOutOfBoundsException e){
return false;
}
}
public static void execute(String[] inputString){
boolean[] result = new boolean[inputString.length];
int count = 0;
for(String str : inputString){
result[count] = isSlurpy(str);
count++;
}
System.out.println("SLURPYS OUTPUT");
for(boolean str : result){
System.out.println(str ? "YES" : "NO");
}
System.out.println("END OF OUTPUT");
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
int count = sc.nextInt();
String[] inputString = new String[count];
for(int i=0; i<count; i++){
inputString[i] = sc.next();
}
sc.close();
execute(inputString);
}
}
3
AHDFG
ADFGCDFFFFFG
ABAEFGCCDFEFFFFFG
SLURPYS OUTPUT
YES
YES
YES
END OF OUTPUT
swift4.0으로 작성하였습니다. 정규표현식을 사용하지 않고 만들어본 코드입니다. Char 한글자씩 비교하는 코드입니다. 혹시 에러가 발견된다면 댓글 부탁드립니다...
import Foundation
func isValidSlurpy(_ string: String) -> String{
if string.count < 2 {
return "NO"
}
var offset = 0
offset = isValidSlimp(string, offset)
if offset == -1 {
return "NO"
} else {
if offset == 0 {
return "YES"
}
offset = isValidSlump(string, offset)
if offset == string.count - 1 {
return "YES"
} else {
return "NO"
}
}
}
func isValidSlimp(_ string:String, _ offset:Int) -> Int {
var tempOffset = offset
var index = string.index(string.startIndex, offsetBy: tempOffset)
if string[index] == "A" {
tempOffset += 1
index = string.index(string.startIndex, offsetBy: tempOffset)
if string[index] == "H" {
tempOffset += 1
return tempOffset
} else if string[index] == "B" {
tempOffset += 1
tempOffset = isValidSlimp(string, tempOffset)
if tempOffset == -1 {
return -1
} else {
index = string.index(string.startIndex, offsetBy: tempOffset)
if string[index] == "C" {
return 0
} else {
return -1
}
}
} else {
tempOffset = isValidSlump(string, tempOffset)
if tempOffset == -1 {
return -1
} else {
tempOffset += 1
}
index = string.index(string.startIndex, offsetBy: tempOffset)
if string[index] == "C" {
return 0
} else {
return -1
}
}
} else {
return -1
}
}
func isValidSlump(_ string:String, _ offset:Int) -> Int {
var tmpOffset = offset
var index = string.index(string.startIndex, offsetBy: tmpOffset)
if string[index] == "D" || string[index] == "E" {
tmpOffset += 1
index = string.index(string.startIndex, offsetBy: tmpOffset)
if string[index] == "F" {
while true {
tmpOffset += 1
index = string.index(string.startIndex, offsetBy: tmpOffset)
if string[index] != "F" {
if string[index] == "G" {
return tmpOffset
} else {
tmpOffset = isValidSlump(string, tmpOffset)
if tmpOffset == -1 {
return -1
} else {
return tmpOffset
}
}
}
}
} else {
return -1
}
} else {
return -1
}
}
let count = readLine().map{ Int($0)! }!
var strings:[String] = [String]()
for _ in 0..<count {
let string = readLine()!
strings.append(string)
}
print("==============")
print("SLURPYS OUTPUT")
for string in strings.enumerated() {
print(isValidSlurpy(string.element))
}
print("END OF OUTPUT")
print("==============")
Swift입니다. 정규식 없이 풀었습니다.
import Foundation
func isSlump(_ input: String) -> Bool {
var fCount = 0
var items = Array(input)
if (items[0] == "D" || items[0] == "E") && items[items.count - 1] == "G" {
for i in 1..<(items.count - 1) {
if items[i] != "F" {
break
}
fCount += 1
}
if fCount > 0 {
if items[fCount + 1] == "G" && (fCount + 1) == (items.count - 1) {
return true
} else {
return isSlump(String(items[(fCount + 1)..<items.count]))
}
}
}
return false
}
func isSlimp(_ input: String) -> Bool {
let items = Array(input)
if input == "AH" {
return true
} else if input.starts(with: "AB") && input.last == "C" {
return isSlimp(String(items[2..<(items.count - 1)]))
} else if input.starts(with: "A") && input.last == "C" {
return isSlump(String(items[1..<(items.count - 1)]))
}
return false
}
func isSlurpy(_ input: String) -> Bool {
let items = Array(input)
for i in 2...(items.count - 3) {
let slimp = isSlimp(String(items[0..<i]))
let slump = isSlump(String(items[i..<items.count]))
if slimp && slump {
return true
}
}
return false
}
let count = Int(readLine()!)!
var inputStrings = [String]()
for _ in 1...count {
inputStrings.append(readLine()!)
}
print("SLURPYS OUTPUT")
for item in inputStrings {
if isSlurpy(item) {
print("YES")
} else {
print("NO")
}
}
print("END OF OUTPUT")
import re
b = re.compile('((AH)|((AB)+HC)|A(((D|E)F+)+G)C)(((D|E)F+)+G)')
list1 = []
a = input()
a = int(a)
for i in range(a):
list1.append(input())
print("SLURPYS OUTPUT")
for j in list1:
if b.match(j) != None:
print("YES")
else:
print("NO")
print("END OF OUTPUT")
package h_slurpy;
public class Check {
int i,j;
boolean slump(String S, int a, int b){
if(S.charAt(a)=='D'||S.charAt(a)=='E'){ //첫글자는 D,E
for(i=a+1;i<b;i++) if(S.charAt(i)!='F') break;
if(i>a+1&&i<b){ //두번째글자부터 하나이상 F
if(i==b-1 && S.charAt(i)=='G') return true; //F뒤에는 'G'로 끝남
else if( slump(S,i,b) ) return true; //F뒤 또다른 slump일 경우
else return false;
} else return false;
} else return false;
}
boolean slimp(String S, int a, int b){
if(S.charAt(a)=='A'){ //첫글자는 A
if(a+2==b && S.charAt(a+1)=='H') return true; //두글자 AH
else if(S.charAt(a+1)=='B' && S.charAt(b-1)=='C' && slimp(S, a+2, b-1)) return true;
else if(S.charAt(b-1)=='C' && slump(S, a+1, b-1)) return true;
else return false;
} else return false;
}
boolean slurpy(String S){
int l=S.length(); int d;
for(i=l-1;i>=0;i--) if(S.charAt(i)=='C'||S.charAt(i)=='H') break;
if(i<0) return false;
else{
d=i+1;
if( slimp(S, 0, d) && slump(S, d, l) ) return true;
else return false;
}
}
}
package h_slurpy;
import java.util.Scanner;
public class Slurpy {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
Check C=new Check();
int N, i;
N=in.nextInt();
while(!(N>0&&N<=10)){ System.out.print("N:1~10의 정수. 다시입력해주세요"); N=in.nextInt();}
String[] input=new String[N];
for(i=0;i<N;i++) input[i]=in.next(); //input[i]는 1~60개의 알파벳문자
System.out.println("SLURPYS OUTPUT");
for(i=0;i<N;i++){
if(C.slurpy(input[i])) System.out.println("YES");
else System.out.println("NO");
}
System.out.println("END OF OUTPUT");
}
}
import regex as re
reSlump = re.compile("([D|E]F+G)+G") reSlimp = re.compile("AH|A([D|E]F+G)+GC|AB(?R)C")
def testSlurpy(testCase): m = re.match(reSlimp, testCase) if m: postFix = testCase[len(m.group()):] return re.fullmatch(reSlump, postFix) != None else: return False
if name == "main": n = input("input test count : ") testCases = [input("Test case " + str(i+1) + " : ").upper() for i in range(int(n))] print("-"*50) print("SLURPYS OUTPUT") for testCase in testCases: print("YES" if testSlurpy(testCase) else "NO") print("END OF OUTPUT")
import java.util.Scanner;
public class Slurpy {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int count = sc.nextInt();
sc.nextLine();
String[] Slurpys = new String[count];
for (int i = 0; i < count; i++) {
Slurpys[i] = sc.nextLine();
}
System.out.println("SLURPYS OUTPUT");
for (int i = 0; i < Slurpys.length; i++) {
System.out.println(Slurpy(Slurpys[i]) ? "YES" : "NO");
}
System.out.println("END OF OUTPUT");
}
public static boolean Slurpy(String str) {
for (int i = 0; i < str.length(); i++) {
if (Slimp(str.substring(0, i)) && Slump(str.substring(i)))
return true;
}
return false;
}
public static boolean Slimp(String str) {
if (str.endsWith("C") && ((str.startsWith("AB") && Slimp(str.substring(2, str.length() - 1))) || (str.startsWith("A") && Slump(str.substring(1, str.length() - 1)))) || str.equals("AH"))
return true;
return false;
}
public static boolean Slump(String str) {
if ((str.startsWith("DF") || str.startsWith("EF")) && str.endsWith("G") && (str.length() == 3 || Slump(str.substring(2)) || (str.charAt(2) == 'F' && Slump(str.substring(0, 2) + str.substring(3)))))
return true;
return false;
}
}
import re
def isslump(s):
while 1:
if not re.match('^[DE]F+',s):
if s != 'G': return False
else: return True
s = re.sub('^[DE]F+','',s)
def isslimp(s):
if s == 'AH': return True
if s[0] != 'A' or s[-1] != 'C' or len(s) <= 3: return False
if s[1:-1][0] == 'B': return isslimp(s[2:-1])
else: return isslump(s[1:-1])
def isslurpy(s):
if not re.search('[DE]F+.*G$',s): return False
else:
if isslimp(s[:re.search('[DE]F+.*G$',s).start()]) and isslump(s[re.search('[DE]F+.*G$',s).start():]):
return True
return False
def print_slurpy(ss):
print('-'*20,'\nSLURPYS OUTPUT')
for s in ss:
print('Yes') if isslurpy(s) else print('No')
print('END OF OUTPUT')
if __name__ == "__main__":
n = int(input())
s = [input() for i in range(n)]
print_slurpy(s)
2
AHDFG
DFGAH
--------------------
SLURPYS OUTPUT
Yes
No
END OF OUTPUT
def Slump(s):
a = 0
if s[0] == 'D' or s[0] == 'E' and 'F' in s:
s = s[s.index('F') + s.count('F'):]
if Slump(s) == 1 or s[-1] == 'G':
a = 1
return 1 if a == 1 else 0
def Slimp(s):
a = 0
if s[0] == 'A':
if (len(s)==2 and s[1]=='H' or
s[1] == 'B' and s[-1] == 'C' and Slimp(s[2:-1]) == 1 or
s[-1] == 'C' and Slump(s[1:-1]) == 1):
a = 1
return 1 if a == 1 else 0
def Slurpy(s):
l = len(s) - list(reversed(s)).index('C') if 'AH' not in s else 2
if Slimp(s[:l]) == 1 and Slump(s[l:]) == 1:
return 1
else:
return 0
def Find_Slurpy(n):
string = []
for s in range(n):
string.append(input("String : "))
print('SLURPYS OUTPUT')
for s in string:
if Slurpy(s) == 1:
print('YES')
else:
print('NO')
파이썬은 저런 정규표현식 사용방법이 없을까요;; 정규식 재사용으로 인한 가용성이 어마어마하네요... 그래도 일단 가장 짧게 구현한 것 같아 올립니다 ㅠㅠ
import re
isSlump= re.compile('(?P<n>[DE]F+G*)+G$')
def isSlimp(str1):
if str1 == 'AH': return True
if len(str1) > 3 and str1[:2] == 'AB' and str1[-1] == 'C':
return isSlimp(str1[2:-1])
elif len(str1) > 2 and str1[0] == 'A' and str1[-1] == 'C':
return isSlump.match(str1[1:-1])
return False
def isSlurpy(str1):
return False if not isSlump.search(str1) else isSlimp(re.sub('([DE]F+G*)+G$', '', str1))
print('SLURPYS OUTPUT')
for i in range(int(input())):
print("YES" if isSlurpy(input()) else "NO")
print('END OF OUTPUT')
출력
SLURPYS OUTPUT
2
AHDFG
YES
DFGAH
NO
END OF OUTPUT
def is_slump(string):
#길이
if(len(string) < 3): return False
#F 앞부분
if(string[0] != 'D' and string[0] != 'E'): return False
if(string[1] != 'F'): return False
#F부분
i = 1
while(string[i] == 'F'):
i = i+1
if(i == len(string)): return False
#F 뒷부분
if(string[i] == string[-1]): #마지막 문자인 경우
if(string[i] == 'G'): return True
else:
return is_slump(string[i:])
#위의 경우가 아니면
return False
def is_slimp(string):
#길이
if(len(string) < 2): return False
if(string[0] != 'A'): return False
if(len(string) == 2):
if(string[1] == 'H'): return True
else: return False
#두 개의 문자 이상일 때
if(string[-1] != 'C'): return False
if(string[1] == 'B'):
return is_slimp(string[2:-1])
else:
return is_slump(string[1:-1])
#위의 경우가 아니면
return False
def is_slurpy(string):
#길이
#if(len(string) < 5): return False
i = len(string) - 1
while(string[i] != 'H' and string[i] != 'C'):
i = i-1
if(i<0): return False
result1 = is_slimp(string[:i+1])
result2 = is_slump(string[i+1:])
return (result1 and result2)
n = int(input())
print('SLURPYS OUTPUT')
for i in range(n):
string = input()
result = is_slurpy(string)
if(result): print('YES')
else: print('NO')
print('END OF OUTPUT')
#include <iostream>
using namespace std;
int isSlump (char *s);
int isSlimp (char *s);
int main()
{
int n=0;
int t=0;
char heap[10][60];
cin>>n;
for(int i=0;i<n;i++){
cin>>heap[i];
}
cout<<"SLURPYS OUTPUT"<<endl;
for(int i=0;i<n;i++){
t=isSlimp(heap[i]);
if(t)
{
if(isSlump(heap[i]+t+1)) {
cout<< "Yes"<<endl;
}
} else cout<<"NO"<<endl;
}
cout<<"End of OUTPUT"<<endl;
}
int isSlump (char * s)
{
int c=0;
char * temp= s;
if(*temp=='D'||*temp=='E'){
temp++,c++;
if (*temp == 'F') temp ++,c++;
else return 0;
while (*temp=='F') temp++,c++;
if(isSlump(temp)) c+=isSlump(temp);
else if (*temp=='G') return c;
else return 0;
}else return 0;
}
int isSlimp (char *s)
{
int c=0;
int t=0;
char * temp= s;
if(*temp=='A'){
temp++,c++;
if(*temp=='H') return c;
else if (*temp=='B'){
temp++,c++;
if(isSlimp(temp)){
t=isSlimp(temp);
temp+=t,c+=t;
}
}else if(isSlump(temp)){
t=isSlump(temp);
temp+=t,c+=t;
}else return 0;
temp++,c++;
if(*temp=='C') return c;
else return 0;
}else return 0;
}
슬러피 끝 문자가 널 문자인지 체크해야하는데 빼먹었네요. 일단 되는거 같아서 그냥 올립니다
import java.util.Scanner;
public class KimSanghyeop {
public static void main(String args[])
{
// 입력단
Scanner sc = new Scanner (System.in);
System.out.print("입력 라인수 : ");
int num_line = Integer.valueOf(sc.nextLine());
String[] input_str= new String[num_line];
for(int f1=0;f1<num_line;f1++)
{
input_str[f1] = sc.nextLine();
}
System.out.println("슬러피 아웃풋");
for(int f1=0;f1<num_line;f1++)
{
System.out.println( Slurpy(input_str[f1]) ? "YES" : "NO");
}
}
static boolean Slurpy(String str)
{
int idx_end=1;
for(idx_end=2;idx_end < str.length();idx_end++)
{
if(Slimp(str.substring(0,idx_end)) && Slump(str.substring(idx_end)))
{
return true;
}
}
return false;
}
static boolean Slimp(String str)
{
if(!str.substring(0,1).equals("A"))
{
return false;
}
if(str.substring(0,2).equals("AH"))
{
return true;
}
int idx_end;
idx_end = -1;
for(int f1=0;f1<str.length();f1++)
{
if(str.charAt(f1) == 'C' )
{
idx_end=f1;
}
}
if(idx_end < 4)
{
return false;
}
if(str.substring(0,2).equals("AB"))
{
return Slimp(str.substring(2, idx_end));
}
else if(str.substring(0,1).equals("A"))
{
return Slump(str.substring(1,idx_end));
}
return false;
}
static boolean Slump(String str)
{
if(!(str.substring(0,1).equals("D") || str.substring(0,1).equals("E")))
{
return false;
}
if(str.indexOf('F')!=1)
{
return false;
}
int idx_begin, idx_end;
idx_begin=1;
idx_end = str.indexOf('G');
for(int f1=1;f1<str.length();f1++)
{
if(str.charAt(f1)!='F')
{
idx_begin=f1;
break;
}
}
if(idx_end<2)
{
return false;
}
if(idx_end== idx_begin)
{
return true;
}
return Slump(str.substring(idx_begin, idx_end+1));
}
}
#include<string>
#include<iostream>
using namespace std;
void slurp(string s);
int slump(string s);
int slimp(string);
int main(void)
{
string s;
getline(cin, s);
slurp(s);
}
int slimp(string s)
{
if (s.length() == 2 &&s[1] == 'H')
{
return 0;
}
else if(s[0] == 'A' && s[1] == 'B'&&s[s.length() - 1] == 'C') {
string part = s.substr(2, s.length() - 3);
slimp(part);
}
else if (s[0] == 'A'&&s[s.length() - 1] == 'C')
{
string part = s.substr(1, s.length() - 2);
slump(part);
}
else return -1;
}
int slump(string s) {
if ((s[0] == 'D' || s[0] == 'E')&&s.find('F', 1) != -1&&s[s.length()-1]=='G')
{
string part = s.substr(s.find('F', 1) + 1, s.length() - s.find('F', 1) - 1);
return 0;
}
else
{
return -1;
}
}
void slurp(string s)
{
int cnt = 0;
int num1, num2;
int i, j;
for (i = 0; i < s.size(); i++) {
num1 = slimp(s.substr(0, i + 1));
cnt++;
if (num1 != -1)
{
string part = s.substr(i + 1, s.size() - 1 - i);
num2 = slump(part);
if (num1 != -1 && num2 != -1) {
cout << "slurpy" << endl;
return;
}
else
{
}
}
}
}
import re
def isSlump(s):
p1 = re.compile('^(D|E)F+G$')
p2 = re.compile('^(D|E)F+(.*G)$')
if p1.match(s): return True
if p2.match(s): return isSlump(p2.sub("\g<2>", s))
else: return False
def isSlimp(s):
p1 = re.compile('^AH$')
p2 = re.compile('^A(.+)C$')
p3 = re.compile('^AB(.+)C$')
if p1.match(s): return True
m2 = p2.match(s)
if m2:
if isSlump(m2.group(1)):
return True
m3 = p3.match(s)
if m3: return isSlimp(m3.group(1))
else: return False
def isSlurpy(s):
bd = len(s) - s[::-1].find('C')
if bd > len(s): bd = len(s) - s[::-1].find('H')
if bd > len(s): return False
first = s[:bd]
second = s[bd:]
if isSlimp(first) and isSlump(second): return True
else: return False
L = []
for i in range(int(input("개수를 입력하세요:"))):
_input = input()
if isSlurpy(_input): L.append("YES")
else: L.append("NO")
print("\nSLURPYS OUTPUT")
for i in range(len(L)):
print(L[i])
print("END OF OUTPUT")
파이썬 3.7.2
import sys
def del_overlap(s: str): #중복 제거 함수
a = ""
for x in range(len(s)-1):
if s[x+1] != s[x]:
a += s[x]
a += s[len(s)-1]
return a
def is_slump(s: str): #스럼프 확인 함수
a = del_overlap(s)
if len(s) == 2:
return False
for x in range(len(s)-1):
if s[x] not in ['D','E','F','G']:
return False
for n in range(1, int((len(a)-1)/2)):
if a[2*n-2] not in ['D', 'E']:
return False
if a[2*n-1] != "F":
return False
if a[-1] != "G":
return False
return True
def is_slimp(s: str): #스림프 확인 함수
if s[0] != 'A':
return False
if len(s) == 2 and s[1] == 'H':
return True
else:
if s[1] == 'B' and s[-1] == 'C' and len(s) != 3 and is_slimp(s[2:-1]):
return True
if s[-1] == 'C' and is_slump(s[1:-1]):
return True
return False
def is_slurpy(s: str): #스러피 확인 함수
try:
if 'H' in s and 'C' not in s:
n = s.index('H')
a = s[:n+1]
b = s[n+1:]
if is_slimp(a) and is_slump(b):
return True
else:
return False
elif 'C' in s:
if list(s).count('C') == 1:
n = s.index('C')
a = s[:n+1]
b = s[n+1:]
if is_slimp(a) and is_slump(b):
return True
else:
return False
else:
ex = list(s).copy()
ex.reverse()
n = ex.index('C')
A = list(s)[:len(s)-n]
B = list(s)[len(s)-n:]
a = ""
b = ""
for x in range(len(A)):
a += A[x]
for x in range(len(B)):
b += B[x]
if is_slimp(a) and is_slump(b):
return True
else:
return False
except:
return False
n = int(input("N : "))
if n < 1 or n > 60:
print("N의 범위를 벗어났습니다!")
sys.exit
a = []
for x in range(1, n+1):
a.append(str(input(str(x)+". ")))
print("\nSLURPYS OUTPUT")
for x in range(n):
if is_slurpy(a[x]):
print("YES")
else:
print("NO")
print("END OF OUTPUT")
def isslump (s) :
index = 0
if len(s) < 3 :
return False
if s[index] == 'D' or s[index] == 'E' :
index+=1
if s[index] == 'F' :
index+=1
if s[index] == 'G' and len(s) == 3 :
return True
elif s[index] == 'F' :
for s_v in s[index:]:
if s_v is not 'F' :
return False
index+=1
if (s[index] == s[-1]) and s[index] == 'G' :
return True
else :
return False
elif s[index] == 'D' or s[index] =='E' :
return isslump(s[index:])
def isslimp(s):
index = 0
if len(s) <2 :
return False
if s[index] == 'A':
index+=1
if s[index] == 'H' and len(s) == 2 :
return True
elif s[index] == 'B' and s[len(s)-1] == 'C':
index+=1
return isslimp(s[index:len(s)-1])
elif s[len(s)-1] == 'C' :
return isslump(s[index:len(s)-1])
return False
def isslurpy(s) :
if len(s) < 5 :
return False
index = 0
if s.find('C') != -1 :
index = s.rfind('C')+1
elif s.find('H') != -1 :
index = s.find('H')+1
slimp_buf = s[:index]
slump_buf = s[index:]
if isslump(slump_buf) and isslimp(slimp_buf) :
return True
else : return False
count_num = int(input())
buf = ['NO' for i in range(int(count_num))]
for k in range(count_num) :
if isslurpy(input()) :
buf[k] = 'YES'
for a in buf :
print(a)
print(END OF OUTPUT)
재귀함수가 포인트가 되는 문제 입니다
다른 분에 비해 좀 길게 풀었습니다
import regex as re
re_slump = re.compile('^([DE]F+G*)+G$')
re_slimp = re.compile('AH|A([DE]F+G*)+GC|AB(?R)C')
def slurpys(in_str):
res = False
mat = re.match(re_slimp, in_str)
if mat:
mat_size = len(mat.group())
sub_str = in_str[mat_size:]
if re.fullmatch(re_slump, sub_str):
res = True
return res
# ex
print(slurpys('ADFGCDFFFFFG'))
PHP
$fIsSlimp = function($str) use(&$fIsSlimp) {
$result = preg_match("/^(?:AH|A(?:[DE]F+)+GC|AB(.+)C)$/", $str, $matches);
return $result ? !!$result || $fIsSlimp($matches[0]) : false;
};
$fIsSlurpy = function($str) use(&$fIsSlimp) {
$result = preg_match("/^(?:AH|A(?:[DE]F+)+GC|AB(.+)C)(?:[DE]F+)+G$/", $str, $matches);
return $result ? !!$result || $fIsSlimp($matches[0]) : false;
};
$result = [];
$result[] = 'SLURPUS OUTPUT';
for ($i = 1, $cnt = intval($arr[0]); $i <= $cnt; $i++) {
$result[] = $fIsSlurpy($arr[$i]) ? 'YES' : 'NO';
}
$result[] = 'END OF OUTPUT';
$result = implode(PHP_EOL, $result);
print_r($result);
/*
SLURPYS OUTPUT
YES
NO
END OF OUTPUT
*/
funnystyle님 풀이 참고했습니다.
static string Mid(string s, string a, string b)
{
int n = a.Length, m = b.Length, o = s.Length;
return s.StartsWith(a) && s.EndsWith(b) ? s.Substring(n, o - n - m) : "";
}
static bool Slump(string s)
{
return s.Replace("DF","").Replace("EF","").TrimStart('F') == "G" && "DE".Contains(s[0]);
}
static bool Slimp(string s)
{
return s.Any() && (s == "AH" || Slump(Mid(s, "A", "C")) || Slimp(Mid(s, "AB", "C")));
}
static bool Slupy(string s)
{
return s.Where((p, i) => Slimp(s.Substring(0, i)) && Slump(s.Substring(i))).Any();
}
public static void Main()
{
var args = Console.In.ReadToEnd().Trim().Split('\n').Skip(1);
var result = string.Join("\n", args.Select(p => Slupy(p) ? "YES" : "NO"));
Console.Write("SLURPYS OUTPUT\n{0}\nEND OF OUTPUT\n", result);
}
입력:
7
AHDFG
DFGAH
AHDFG
ABAHCEFG
ABABAHCCDFFFFFG
ADFGCDFDFDFDFG
ADFFFFGCDFEFFFFFG
결과:
SLURPYS OUTPUT
YES
NO
YES
YES
YES
YES
YES
END OF OUTPUT
파이썬 3입니다. 슬럼프, 슬림프, 스러피를 판단하는 함수를 정의한 다음에 문제를 해결했습니다.
def is_slump(x):
num_slump = x.count('D') + x.count('E')
if (len(x) != num_slump + x.count('F') + x.count('G')) or (x[0] != 'D' and x[0] != 'E') or x[-1] != 'G':
return False
elif num_slump == 1:
return set(x.strip('DEG')) == {'F'}
else:
return is_slump(x.strip('DE').strip('F'))
def is_slimp(x):
if x == 'AH':
return True
elif len(x) <= 3:
return False
elif x[0] != 'A' or x[-1] != 'C':
return False
else:
return is_slump(x[1:-1]) or (x[1] == 'B' and is_slimp(x[2:-1]))
def is_slurpy(x):
if len(x) <= 4:
return False
else:
for i in range(2, len(x) - 2):
if is_slimp(x[:i]) and is_slump(x[i:]):
return True
return False
N = int(input())
YESNO = []
for i in range(N):
if is_slurpy(input()):
YESNO.append('YES')
else:
YESNO.append('NO')
print('SLURPYS OUTPUT')
for YN in YESNO:
print(YN)
print('END OF OUTPUT')
import regex as re
reSlump = re.compile("([D|E]F+G)+G") reSlimp = re.compile("AH|A([D|E]F+G)+GC|AB(?R)C")
def testSlurpy(testCase): m = re.match(reSlimp, testCase) if m: postFix = testCase[len(m.group()):] return re.fullmatch(reSlump, postFix) != None else: return False
if name == "main": n = input("input test count : ") testCases = [input("Test case " + str(i+1) + " : ").upper() for i in range(int(n))] print("-"*50) print("SLURPYS OUTPUT") for testCase in testCases: print("YES" if testSlurpy(testCase) else "NO") print("END OF OUTPUT")
import re
class identifyString:
def __init__(self):
self.A = ""
self.B = ""
self.iA = 0
self.iB = 0
def testStr(self,line):
p1 = re.compile(r"(A.*C)(.+$)")
p2 = re.compile(r"(AH)(.+$)")
m = p1.match(line)
n = p2.match(line)
if m:
self.A = m.group(1)
self.B = m.group(2)
elif n:
self.A = n.group(1)
self.B = n.group(2)
if m or n:
self.iB = self.testSlump(self.B)
if self.iB == 0:
print("NO")
else:
self.iA = self.testSlimp(self.A)
if self.iA == 1:
print("YES")
else:
print("NO")
def testSlimp(self,line):
p1 = re.compile(r"^AH")
p2 = re.compile(r"^AB(.+)C")
p3 = re.compile(r"A[!HB](.+)C]")
m = p1.match(line)
n = p2.match(line)
o = p3.match(line)
if m:
return 1
elif n:
r = self.testSlimp(n.group(1))
if r == 1:
return 1
else:
return 0
elif o:
r = self.testSlump(o.group(1))
if r == 1:
return 1
else:
return 0
else:
return 0
def testSlump(self,line):
p = re.compile(r"(^[DE]F+)(.+)")
m = p.match(line)
if m and m.group(2) == "G":
return 1
elif m and m.group(2) != "G":
result = self.testSlump(m.group(2))
if result == 1:
return 1
else:
return 0
else:
return 0
a = identifyString()
a.testStr("AHDFG")
a.testStr("DFGAH")
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
using namespace std;
int _count=0;
bool is_slump(string& s) {
int i =1;
if (s[0]=='D' || s[0]=='E') {
if(s[1]=='F') {
while(s[++i]=='F') {
}
if(s[i]=='G' && i==s.length()-1) {
return true;
}
else if(s.length() > i+1) {
s.erase(0,i);
return is_slump(s);
}
return false;
}
}
return false;
}
bool is_slimp(string& s) {
if (s[0]=='A') {
if(s.length()==2 && s[1]=='H') {
return true;
}
if(s[1]=='B') {
s.erase(0,2);
if(s.at(s.length()-1)!='C') {
return false;
}
s.erase(s.length()-1);
return is_slimp(s);
}
else {
s.erase(0,1);
if(s.at(s.length()-1)!='C') {
return false;
}
s.erase(s.length()-1);
return is_slump(s);
}
}
return false;
}
bool is_slurpy(string& s) {
int distint,i;
for(i =s.length()-1;i>=0;i--) {
if(s.at(i)=='C') {
distint=0;
break;
}
else if( s.at(i)=='H') {
distint=1;
break;
}
if (i==s.length()) {
return false;
}
}
string ss=s;
if(distint==1) {
s.erase(0,2);
return is_slump(s);
}
else if(distint==0) {
ss.erase(i+1);
s.erase(0,i+1);
return is_slimp(ss) && is_slump(s);
}
return false;
}
int main() {
int count;
cin >> count;
string ss;
vector<string> group;
while(count--) {
cin >> ss;
group.push_back(ss);
}
cout << "SLURPYS OUTPUT" << endl;
for(int i =0;i<group.size();i++) {
if(is_slurpy(group[i])) {
cout << "YES" << endl;
}
else {
cout << "NO" << endl;
}
}
cout << "END OF OUTPUT" << endl;
return 0;
}
import re
def Slump(a):
while True:
if re.search('^EF',a) and a[-1]=='G' :
a=a[2:]
while True:
if a[0]=='F':
a=a[1:]
else:
break
elif re.search('^DF',a) and a[-1]=='G' :
a=a[2:]
while True:
if a[0]=='F':
a=a[1:]
else:
break
elif a=='G':
return True
else:
return False
def Slimp(a):
while True:
if len(a)==2 and a[0]=='A' and a[1]=='H':
return True
elif len(a)>2 and a[0]=='A' and a[-1]=='C':
if a[1]=='B':
a = a[2:-1]
else:
a=a[1:-1]
if Slump(a)==True:
return True
break
else:
return False
def Slurpy(count):
i=0
print("SLURPYS OUTPUT")
while i<count:
a = input("판단할 단어를 입력하세요 : ")
idx = a.rfind('C')
b = a[:idx+1]
c = a[idx+1:]
if a[0]=='A' and a[1]=='H':
a=a[2:]
if Slump(a):
print("YES")
else:
print("NO")
elif Slimp(b) and Slump(c):
print("YES")
else:
print("NO")
i+=1
print("END OF OUTPUT")
Slurpy(int(input("횟수 : ")))
#슬럼프 판정 알고리즘 만들기.
#판정할 문자열이 필요.
x='DFFFFEFFFDFF'
'''
이 문자열에서 슬럼프 여부를 판정. 슬럼프의 범위 후보가 x의 길이를 넘어서면,
이 문자열은 슬럼프가 아닌걸로 판정.
'''
#우선 변수부터 정의-문자열이 정의되기 전에 인식 됨(가능).
SUMallcon=[0,0]
SUMcurcon=[0,0]
SUMallcan=[0,0]
SUMcurcan=[0,0]
'''
SUM체크함수를 정의-체크함수는 특정 문자열 내의 슬럼프 존재여부 및 존재하는
슬럼프의 해당 문자열 내 범위를 판정한다.
'''
def SUM(x):
global SUMallcon
global SUMcurcon
global SUMallcan
global SUMcurcan
SUMallcon=[0,0]#정의
SUMcurcon=[0,0]
#이미 체크 대상으로 하는 문자열 x가 함수 내부에서 정의됨.
'''
그리고 이제부터 x의 첫번째 문자의 번호,
즉 0을 변수들로 인식-'슬럼프 후보'라는 변수의 항목들에 대입.
(인식 내용이 체크의 결과로 바뀌게 됨.)
'''
SUMallcan[0]=0
SUMallcan[1]=0
SUMcurcan[0]=0
SUMcurcan[1]=0
'문자열변수가 제대로 입력 되었는지 확인'
'''
'x에서 체크하고자 하는 문자번호'를 정의함(1씩 커질 예정.).
처음에는 0이 그 변수로 정의됨. 이 인식의 표기문자는 i.
'''
i=0
#i가 x의 마지막 번호를 넘지 않는 동안 체크행위를 반복
while i<=len(x)-1:
t=x[i]#반복문이 시작될 때 마다 t가 재 정의됨.
#아래 조건은 t가 스럼프 전체 시작 후보이자 현재 시작 후보인지를 물음.
if SUMallcan[0]==SUMcurcan[0]==SUMallcan[1] and (t=='D' or t=='E'):
i+=1 #t의 번호를 다음으로 넘김
SUMallcan[1]=i
SUMcurcan[1]=i
#아래 조건은 t가 (전체의 상태와 무관하게) 현재 스럼프 중간 후보인지를 물음.
elif SUMcurcan[0]<SUMcurcan[1] and t=='F':
i+=1 #t의 번호를 다음으로 넘김
SUMallcan[1]=i
SUMcurcan[1]=i
#아래 조건은 t가 스럼프의 전체시작 후보가 아니면서 현재시작 후보인지를 물음.
elif SUMcurcan[0]+1<SUMcurcan[1] and (t=='D' or t=='E'):
SUMcurcan[0]=i#i가 더해지기 전에 대입.
i+=1
SUMallcan[1]=i
SUMcurcan[1]=i
#아래 조건은 t가 스럼프의 끝인지(스럼프 확정인지)를 물음.
elif SUMcurcan[0]+1<SUMcurcan[1] and t=='G':
SUMallcon=SUMallcan
SUMcurcon=SUMcurcan
break #주의!- 뒷 부분때문에 x 전체는 스럼프가 아닐 수 있다.
#주석처리- (i+=1#반복문 탈출용)
#아래 조건은 t가 스럼프의 일부가 아닌지를 물음.
else :
i+=1
SUMallcan[0]=i
SUMallcan[1]=i
SUMcurcan[0]=i
SUMcurcan[1]=i
break
y='ABABAEFFFDFGCCC'
K=0
def SIM(y):
global K#스림프 판정용 변수
K=0#SIM이 실행될 때 마다 초기화.
#y에서 먼저, 어디서 부터 어디를 판정과정을 거치게 할건지 정의.
yc=y#처음엔 y전체에 대해 판정.
#yc의 첫문자부터 판정.
if yc[0]=='A' and len(yc)>=2:
#일단 첫번째 조건은 합격.
#2문자면?
if len(yc)==2:
if yc[1]=='H':
K=1
#문자가 둘 이상이면?
else:
if yc[-1]=='C' :#C로 끝나나?
'''
아래 조건은 yc가 A+B+스림프+C의 패턴 후보인지 질문.
yc의 3번째(2번)문자부터 -2까지의 문자열이 스림프인지 판정하는 단계로,
마지막 스림프가 확정되면 처음 y를 확정.
'''
if yc[1]=='B':
SIM(yc[2:-1])# 내부가 스림프인지 알아봄.
else: #A+스럼프+C 패턴이 되거나, 그렇지 않으면 탈락.
SUM(yc[1:-1])#yc내부에 대해 스럼프 체크
if SUMallcon!=[0,0] :
K=1
#스러피: 스러피(Slurpy)는 스림프(Slimp) 뒤에 스럼프(Slump)로 구성되는 문자열이다.
z='ABAEFFGCCEFFFFG'
'''
z의 내부 범위를 한 칸씩 늘려가면서 스림프 체크.
스림프 확정된 내부범위의 바로 다음 문자부터 끝문자까지의 문자열의 스럼프 여부를 확인.
'''
def SUR(z):
V=0
i=1#문자열의 끝부분 번호.
while V==0 and i<= len(z)-1:#V는 스림프가 체크되면 1로 바뀜.
zi=z[0:i]#z의 스림프 파트.
SIM(zi)
if K==1:
SUM(z[i:])#그 뒤의 스럼프 여부 체크-con이 키포인트.
if SUMallcon!=[0,0]:#그 뒤가 스럼프인가?
print('YES')
V=1#탈출
else:
print('NO')
V=1
else:
i+=1
if i>len(z)-1:
print('NO')
d=1
l=[]
n=input('n의 값은?')
while d<=int(n):
x=input('이번에 체크 대상에 넣을 문자열은?')
l.append(x)
d+=1
print('SLURPYS OUTPUT')
s=0
while s<=int(n)-1:
SUR(l[s])
s+=1
print('END OF OUTPUT')
#include <stdio.h>
#include <string.h>
#define ROW 10
#define COLUMN 60
#define STATE_COLUMN 10
struct data
{
char input_data[ROW][COLUMN];
char slurpy_state[ROW][STATE_COLUMN];
} user;
int main(int argc, char *argv[])
{
int N;
int row;
int column;
int count_AB1;
int count_C1;
int count_AB2;
int count_C2;
int count_AB3;
int count_A2;
int count_C4;
int count_G2;
int count_G3;
int count_G4;
int count_G5;
int count_G6;
int count_G7;
int count_G8;
int count_G9;
for (row = 0; row < ROW; row++)
{
for (column = 0; column < COLUMN; column++)
{
user.input_data[row][column] = '\0';
}
}
for (row = 0; row < ROW; row++)
{
strcpy(&user.slurpy_state[row][0], "NO");
}
scanf("%d", &N);
for (row = 0; row < N; row++)
{
printf("%d:", (row + 1));
scanf("%s", &user.input_data[row][0]);
}
row = 0;
while (row < N)
{
column = 0;
count_G8 = 0;
if ('A' == user.input_data[row][column])
{
column++;
D_E1:
if ('D' == user.input_data[row][column] || 'E' == user.input_data[row][column])
{
column++;
F1:
if ('F' == user.input_data[row][column])
{
column++;
if ('F' == user.input_data[row][column])
{
goto F1;
}
if ('D' == user.input_data[row][column] || 'E' == user.input_data[row][column])
{
goto D_E1;
}
}
if ('G' == user.input_data[row][column])
{
column++;
if ('C' == user.input_data[row][column])
{
column++;
D_E10:
if ('D' == user.input_data[row][column] || 'E' == user.input_data[row][column])
{
column++;
F10:
if ('F' == user.input_data[row][column])
{
column++;
if ('F' == user.input_data[row][column])
{
goto F10;
}
if ('D' == user.input_data[row][column] || 'E' == user.input_data[row][column])
{
goto D_E10;
}
G8:
if ('G' == user.input_data[row][column])
{
count_G8++;
column++;
if ('G' == user.input_data[row][column])
{
goto G8;
}
else if ('\0' != user.input_data[row][column])
{
strcpy(&user.slurpy_state[row][0], "NO");
goto end;
}
}
if (count_G8 == 1)
{
strcpy(&user.slurpy_state[row][0], "YES");
goto end;
}
}
}
}
}
}
}
column = 0;
count_G2 = 0;
if ('A' == user.input_data[row][column])
{
column++;
D_E4:
if ('D' == user.input_data[row][column] || 'E' == user.input_data[row][column])
{
column++;
F4:
if ('F' == user.input_data[row][column])
{
column++;
if ('F' == user.input_data[row][column])
{
goto F4;
}
if ('D' == user.input_data[row][column] || 'E' == user.input_data[row][column])
{
goto D_E4;
}
G2:
if ('G' == user.input_data[row][column])
{
count_G2++;
column++;
if ('G' == user.input_data[row][column])
{
goto G2;
}
else if ('\0' != user.input_data[row][column])
{
strcpy(&user.slurpy_state[row][0], "NO");
goto end;
}
}
if (count_G2 == 1)
{
strcpy(&user.slurpy_state[row][0], "YES");
goto end;
}
}
}
}
column = 0;
count_G3 = 0;
if ('A' == user.input_data[row][column])
{
column++;
if ('H' == user.input_data[row][column])
{
column++;
D_E5:
if ('D' == user.input_data[row][column] || 'E' == user.input_data[row][column])
{
column++;
F5:
if ('F' == user.input_data[row][column])
{
column++;
if ('F' == user.input_data[row][column])
{
goto F5;
}
if ('D' == user.input_data[row][column] || 'E' == user.input_data[row][column])
{
goto D_E5;
}
G3:
if ('G' == user.input_data[row][column])
{
count_G3++;
column++;
if ('G' == user.input_data[row][column])
{
goto G3;
}
else if ('\0' != user.input_data[row][column])
{
strcpy(&user.slurpy_state[row][0], "NO");
goto end;
}
}
if (count_G3 == 1)
{
strcpy(&user.slurpy_state[row][0], "YES");
goto end;
}
}
}
}
}
column = 0;
count_G4 = 0;
if ('A' == user.input_data[row][column])
{
column++;
if ('B' == user.input_data[row][column])
{
column++;
if ('A' == user.input_data[row][column])
{
column++;
if ('C' == user.input_data[row][column])
{
column++;
D_E6:
if ('D' == user.input_data[row][column] || 'E' == user.input_data[row][column])
{
column++;
F6:
if ('F' == user.input_data[row][column])
{
column++;
if ('F' == user.input_data[row][column])
{
goto F6;
}
if ('D' == user.input_data[row][column] || 'E' == user.input_data[row][column])
{
goto D_E6;
}
G4:
if ('G' == user.input_data[row][column])
{
count_G4++;
column++;
if ('G' == user.input_data[row][column])
{
goto G4;
}
else if ('\0' != user.input_data[row][column])
{
strcpy(&user.slurpy_state[row][0], "NO");
goto end;
}
}
if (count_G4 == 1)
{
strcpy(&user.slurpy_state[row][0], "YES");
goto end;
}
}
}
}
}
}
}
column = 0;
count_G5 = 0;
if ('A' == user.input_data[row][column])
{
column++;
if ('B' == user.input_data[row][column])
{
column++;
if ('A' == user.input_data[row][column])
{
column++;
if ('H' == user.input_data[row][column])
{
column++;
if ('C' == user.input_data[row][column])
{
column++;
D_E7:
if ('D' == user.input_data[row][column] || 'E' == user.input_data[row][column])
{
column++;
F7:
if ('F' == user.input_data[row][column])
{
column++;
if ('F' == user.input_data[row][column])
{
goto F7;
}
if ('D' == user.input_data[row][column] || 'E' == user.input_data[row][column])
{
goto D_E7;
}
G5:
if ('G' == user.input_data[row][column])
{
count_G5++;
column++;
if ('G' == user.input_data[row][column])
{
goto G5;
}
else if ('\0' != user.input_data[row][column])
{
strcpy(&user.slurpy_state[row][0], "NO");
goto end;
}
}
if (count_G5 == 1)
{
strcpy(&user.slurpy_state[row][0], "YES");
goto end;
}
}
}
}
}
}
}
}
column = 0;
count_AB1 = 0;
count_C1 = 0;
count_G6 = 0;
AB1:
if ('A' == user.input_data[row][column])
{
column++;
if ('B' == user.input_data[row][column])
{
count_AB1++;
column++;
if ('A' == user.input_data[row][column])
{
column++;
if ('B' == user.input_data[row][column])
{
column -= 1;
goto AB1;
}
C1:
if ('C' == user.input_data[row][column])
{
count_C1++;
column++;
if ('C' == user.input_data[row][column])
{
goto C1;
}
}
if (count_AB1 == count_C1)
{
D_E8:
if ('D' == user.input_data[row][column] || 'E' == user.input_data[row][column])
{
column++;
F8:
if ('F' == user.input_data[row][column])
{
column++;
if ('F' == user.input_data[row][column])
{
goto F8;
}
if ('D' == user.input_data[row][column] || 'E' == user.input_data[row][column])
{
goto D_E8;
}
G6:
if ('G' == user.input_data[row][column])
{
count_G6++;
column++;
if ('G' == user.input_data[row][column])
{
goto G6;
}
else if ('\0' != user.input_data[row][column])
{
strcpy(&user.slurpy_state[row][0], "NO");
goto end;
}
}
if (count_G6 == 1)
{
strcpy(&user.slurpy_state[row][0], "YES");
goto end;
}
}
}
}
}
}
}
column = 0;
count_AB2 = 0;
count_C2 = 0;
count_G7 = 0;
AB2:
if ('A' == user.input_data[row][column])
{
column++;
if ('B' == user.input_data[row][column])
{
count_AB2++;
column++;
if ('A' == user.input_data[row][column])
{
column++;
if ('B' == user.input_data[row][column])
{
column -= 1;
goto AB2;
}
if ('H' == user.input_data[row][column])
{
column++;
C2:
if ('C' == user.input_data[row][column])
{
count_C2++;
column++;
if ('C' == user.input_data[row][column])
{
goto C2;
}
}
}
if (count_AB2 == count_C2)
{
D_E9:
if ('D' == user.input_data[row][column] || 'E' == user.input_data[row][column])
{
column++;
F9:
if ('F' == user.input_data[row][column])
{
column++;
if ('F' == user.input_data[row][column])
{
goto F9;
}
if ('D' == user.input_data[row][column] || 'E' == user.input_data[row][column])
{
goto D_E9;
}
G7:
if ('G' == user.input_data[row][column])
{
count_G7++;
column++;
if ('G' == user.input_data[row][column])
{
goto G7;
}
else if ('\0' != user.input_data[row][column])
{
strcpy(&user.slurpy_state[row][0], "NO");
goto end;
}
}
if (count_G7 == 1)
{
strcpy(&user.slurpy_state[row][0], "YES");
goto end;
}
}
}
}
}
}
}
column = 0;
count_AB3 = 0;
count_A2 = 0;
count_C4 = 0;
count_G9 = 0;
if ('A' == user.input_data[row][column])
{
column++;
if ('B' == user.input_data[row][column])
{
count_AB3++;
column++;
if ('A' == user.input_data[row][column])
{
count_A2++;
column++;
D_E2:
if ('D' == user.input_data[row][column] || 'E' == user.input_data[row][column])
{
column++;
F2:
if ('F' == user.input_data[row][column])
{
column++;
if ('F' == user.input_data[row][column])
{
goto F2;
}
if ('D' == user.input_data[row][column] || 'E' == user.input_data[row][column])
{
goto D_E2;
}
}
if ('G' == user.input_data[row][column])
{
column++;
C4:
if ('C' == user.input_data[row][column])
{
count_C4++;
column++;
if ('C' == user.input_data[row][column])
{
goto C4;
}
}
if ((count_AB3 + count_A2) == count_C4)
{
D_E11:
if ('D' == user.input_data[row][column] || 'E' == user.input_data[row][column])
{
column++;
F11:
if ('F' == user.input_data[row][column])
{
column++;
if ('F' == user.input_data[row][column])
{
goto F11;
}
if ('D' == user.input_data[row][column] || 'E' == user.input_data[row][column])
{
goto D_E11;
}
G9:
if ('G' == user.input_data[row][column])
{
count_G9++;
column++;
if ('G' == user.input_data[row][column])
{
goto G9;
}
else if ('\0' != user.input_data[row][column])
{
strcpy(&user.slurpy_state[row][0], "NO");
goto end;
}
}
if (count_G9 == 1)
{
strcpy(&user.slurpy_state[row][0], "YES");
goto end;
}
}
}
}
}
}
}
}
}
end:
row++;
}
printf("SLURPYS OUTPUT\n");
for (row = 0; row < N; row++)
{
if (0 == strcmp(&user.slurpy_state[row][0], "YES"))
{
printf("YES\n");
}
if (0 == strcmp(&user.slurpy_state[row][0], "NO"))
{
printf("NO\n");
}
}
printf("END OF OUTPUT\n");
return 0;
}
def isSlump(string):
if len(string)<=1:
return string == 'G'
if (string[0] == 'D' or string[0] == 'E') and string[1]=='F':
idx=2
while idx< len(string) and string[idx]=='F':
idx += 1
return isSlump(string[idx:])
else:
return False
def isSlimp(string):
if len(string)<=2:
return string=='AH'
if string[0:2]=='AB' and string[-1]=='C':
return isSlimp(string[2:-1])
elif string[0]=='A' and string[-1]=='C':
return isSlump(string[1:-1])
else:
return False
def isSlurpy(string):
idx_H, idx_C = -1, -1
for i in range(len(string)):
if string[i]== 'H':
idx_H = i
elif string[i]=='C':
idx_C = i
s1, s2 = '', ''
if idx_C > -1:
s1, s2 = string[:idx_C + 1], string[idx_C + 1:]
elif idx_H > -1:
s1, s2 = string[:idx_H + 1], string[idx_H + 1:]
if isSlimp(s1)==True and isSlump(s2)==True:
return True
else:
return False
slumps_lst = ['DFG', 'EFG', 'DFFFFFG', 'DFDFDFDFG', 'DFEFFFFFG','DFEFF', 'EFAHG', 'DEFG', 'DG', 'EFFFFDG']
slimps_lst = ['AH', 'ABAHC', 'ABABAHCC', 'ADFGC', 'ADFFFFGC', 'ABAEFGCC', 'ADFDFGC','ABC', 'ABAH', 'DFGC', 'ABABAHC', 'SLIMP', 'ADGC']
slurpys_lst = ['AHDFG', 'ADFGCDFFFFFG', 'ABAEFGCCDFEFFFFFG', 'AHDFGA', 'DFGAH', 'ABABCC']
problems = ['AHDFG', 'DFGAH']
for string in slumps_lst:
print('isSlump(%s) :'%string, isSlump(string))
print(' ='*8)
for string in slimps_lst:
print('isSlimp(%s) :'%string, isSlimp(string))
print(' ='*8)
for string in slurpys_lst:
print('isSlurpy(%s) :'%string, isSlurpy(string))
print(' ='*8)
print('\n')
print('SLURPYS OUTPUT')
for string in problems:
print('YES' if isSlurpy(string) else 'NO')
print('END OF OUTPUT')
JAVA입니다.
package slurpy;
import java.io.IOException;
import java.util.Scanner;
public class Slurpy {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();
String[] strs = new String[num];
for (int i = 0; i < num; i++) {
strs[i] = scanner.next();
}
System.out.println("SLRUPYS OUTPUT");
for (String string : strs) {
System.out.println(isSlurpy(string) ? "YES" : "NO");
}
System.out.println("END OF OUTPUT");
}
public static boolean isSlimp(String str) {
char[] charArray = str.toCharArray();
if(charArray[0] != 'A') {
return false; //시작이 A가 아니면 탈락
}
if(charArray.length == 2) {
return charArray[1] == 'H'; //길이가 2일 때 끝이 H가 아니면 슬림프 불가
}
if(charArray[charArray.length - 1] != 'C') {
return false; //길이가 2가 아닐 때 끝이 C가 아니면 탈락(1글자인 경우도 같이 탈락)
}
if(charArray[1] == 'B') { //AB슬림프C
return isSlimp(str.substring(2, str.length() - 1));
}
return isSlump(str.substring(1, str.length() - 1)); //A슬럼프C
}
public static boolean isSlump(String str) {
char[] charArray = str.toCharArray();
if(charArray[0] != 'D' && charArray[0] != 'E') {
return false; //첫 번째 문자가 D, E가 아닌 경우 탈락
}
if(charArray[1] != 'F') {
return false; //다음 문자가 F가 아니면 탈락
}
if(charArray[charArray.length - 1] != 'G') {
return false; //무조건 마지막은 G여야 함
}
if(str.lastIndexOf("F") + 2 == charArray.length) {
return true; //F 다음이 마지막이며 마지막이 G인 경우
}
return isSlump(str.substring(str.lastIndexOf("F") + 1, charArray.length));
//F 직후부터 끝까지가 Slump인지 확인
}
public static boolean isSlurpy(String str) {
if(str.length() <= 1) {
return false;
}
if(str.substring(0, 2) == "AH") { //Slimp 자동 만족
return isSlump(str.substring(2, str.length()));
}
for (int i = 1; i < str.length(); i++) {
if(isSlimp(str.substring(0, i)) && isSlump(str.substring(i))) {
return true; //한 번이라도 Slimp + Slump 구성인 경우 참
//가능한 모든 Slimp + Slump 분할에 대해 검사
}
}
return false;
}
}