파이썬입니다.

삽입은 큰쪽에서 한 개의 문자를 제거하는 것과 같은 조건이므로 고려하지 않았습니다. 두 문자열의 길이가 다른 경우는 큰 문자열에서 하나씩 문자를 제거 해 보았을 때 같은지를 체크했고 두 문자열의 길이가 같은 경우에는 한 개의 문자를 제외한 나머지 문자열이 같은지를 조사해 보았습니다.

def checkRemoval(s1, s2):
    for i in range(len(s1)):
        t = s1[:i]+s1[i+1:]
        if s2==t: return True
    return False

def checkReplace(s1, s2):
    for i in range(len(s1)):
        t1 = s1[:i]+s1[i+1:]
        t2 = s2[:i]+s2[i+1:]
        if t1==t2: return True
    return False

def OneEditApart(s1, s2):
    if len(s1) > len(s2):
        return checkRemoval(s1, s2)
    elif len(s1) < len(s2):
        return checkRemoval(s2, s1)
    else:
        return checkReplace(s1, s2)


print OneEditApart("cat", "dog")
print OneEditApart("cat", "cats")
print OneEditApart("cat", "cut")
print OneEditApart("cat", "cast")
print OneEditApart("cat", "at")
print OneEditApart("cat", "acts")

앞뒤로 같은 것들은 계속 잘라냅니다. 그래서 살아남은게 한쪽에 두 글자 이상 있으면 False가 됩니다.

def OneEditApart(a,b):
    while a and b and a[-1]==b[-1]:a=a[:-1];b=b[:-1]
    while a and b and a[0]==b[0]:a=a[1:];b=b[1:]
    return len(a)<=1 and len(b)<=1 

Python 입니다.

s2 에서 s1 의 문자들의 위치를 봤을 때, Insert 의 경우 모두 위치값이 존재해야 하고, Delete, Update 의 경우 1 문자 빼고는 모두 위치값이 존재해야 한다.

라는 로직을 기본으로 아래와 같이 작성해보았습니다.

def oneEditApart(s1, s2):
    s1_idx_in_s2=[-1]
    for i in range(len(s1)):
        s1_idx_in_s2.append(s2.find(s1[i], s1_idx_in_s2[i]+1))

    s1_idx_in_s2=s1_idx_in_s2[1:]

    if len(s2)==len(s1)+1:
        return True if min(s1_idx_in_s2)>=0 else False
    elif len(s2) in (len(s1), len(s1)-1):
        s1_idx_in_s2.remove(-1)
        return True if min(s1_idx_in_s2)>=0 else False
    else:
        return False

print(oneEditApart("cat", "dog"))
print(oneEditApart("cat", "cats"))
print(oneEditApart("cat", "cut"))
print(oneEditApart("cat", "cast"))
print(oneEditApart("cat", "at"))
print(oneEditApart("cat", "acts"))

Using python

def CheckWord(n, m):
    if len(n) == len(m):
        for i in range(len(n)):
            j = n[:i]+n[i+1:]
            k = m[:i]+m[i+1:]
            if j == k:
                return True
        return False
    elif len(n) > len(m):
        for i in range(len(n)):
            j = n[:i]+n[i+1:]
            if j==m:
                return True
        return False
    elif len(n) < len(m):
        for i in range(len(m)):
            k = m[:i]+m[i+1:]
            if n==k:
                return True
        return False

print CheckWord("cat", "dog")
print CheckWord("cat", "cats")
print CheckWord("cat", "cut")
print CheckWord("cat", "cast")
print CheckWord("cat", "at")
print CheckWord("cat", "acts")

False
True
True
True
True
False
[Finished in 0.1s]

def OneEditApart(a, b):
    if len(a) == len(b): return chktranse(a,b)
    elif abs(len(a)-len(b)) == 1: return chkiandr(a,b)
    else: return False
def chkiandr(a, b):
    a, b = sorted((a, b), key = lambda x: len(x))
    for i in range(len(a)):
        if a[i] != b[i]:
            if a == b[:i]+b[i+1:]: return True
            else: return False
    return True
def chktranse(a, b):
    n = 0
    for i in range(len(a)):
        if a[i] != b[i]:
            n += 1
    return (True if n==1 else False)

삽입과 제거가 본질적으로 같기에 정렬하고 큰쪽을 제거해 확인합니다. 파이썬 3.5.1

Python 3.4.2, difflib.ndiff 와 functools.reduce 사용했습니다.

import difflib
from functools import reduce

def count_diff(str1, str2): # 틀린 것이 하나면 True, 둘이상이면 False
    diff_str = reduce(str.__add__, (difflib.ndiff(str1, str2)))
    return diff_str.count('+') + diff_str.count('-')

def OneEditApart(s1, s2):
    if len(s1) == len(s2): # 두 스트링 글자수가 같을때 한개만 변환인가?
        count = 0
        for (a,b) in zip(s1, s2):
            if a != b:
                count += 1
                if count > 1: return False
        return True
    elif abs(len(s1)-len(s2)) == 1: # 두 스트링이 한개차이일때 한개만 삽입,제거인가?
        if count_diff(s1, s2) == 1: return True
        else: return False
    else: # 두개이상 삽입, 제거한것이면 무조건 False
        return False

실행결과

>>> OneEditApart('cat', 'dog')
False
>>> OneEditApart('cat', 'cats')
True
>>> OneEditApart('cat', 'cut')
True
>>> OneEditApart('cat', 'cast')
True
>>> OneEditApart('cat', 'at')
True
>>> OneEditApart('cat', 'acts')
False
>>> OneEditApart('cat', 'act')
False
>>> OneEditApart('cat', 'scat')
True

if else 를 너무 막 썻네요..;

def CmpWord(a,b):
    n = 0
    cnt = 0
    if len(a)==len(b):
        for i in a:
            if i != b[n]:
                cnt += 1
            if cnt == 2:
                return False
            n += 1
        return True

    else:
        if len(b) > len(a):
            tmp = a
            a = b
            b = tmp

        for i in b:
            if i != a[n]:
                b = b[0:n] + a[n] + b[n:]
                if a == b:
                    return True
                else:
                    return False
            n+=1
        return True


print CmpWord("cat", "dog")
print CmpWord("cat", "cats")
print CmpWord("cat", "cut")
print CmpWord("cat", "cast")
print CmpWord("cat", "at")
print CmpWord("cat", "acts")

False
True
True
True
True
False

[python 2.7.3] 문자수를 먼저 check하여 같으면 변환에 대한 확인만 수행하고, 다른 문자수가 2이상이면 False, 1인 경우 문자수가 큰쪽에서 하나씩 제거해보면서 같은지를 확인합니다.

def OneEditApart(s1,s2) :
    diffCnt = 0
    s1Len = len(s1)
    s2Len = len(s2)

    if s1Len==s2Len :
       for i in range(s1Len) :
           if s1[i] != s2[i] :
               diffCnt += 1
       if diffCnt <= 1 :
            return True
    else :
        if abs(s1Len-s2Len) == 1 :            
            (bigText,smallText) = (s1,s2) if s1Len > s2Len else (s2,s1)
            sL = list(bigText)
            for i in range(len(bigText)) :
                tempL = sL[:]
                tempL.pop(i)                    
                if "".join(tempL)==smallText :
                    return True
    return False

print OneEditApart("cat", "dog")
print OneEditApart("cat", "cats")
print OneEditApart("cat", "cut")
print OneEditApart("cat", "cast")
print OneEditApart("cat", "at")
print OneEditApart("cat", "acts")

# One Edit Apart
def OneEditApart(s1,s2):
    s1, s2 = list(s1), list(s2)
    if len(s1) > len(s2) : s1, s2 = s2, s1
    len_diff = len(s1) - len(s2)
    if len_diff > 1:
        return False
    elif len_diff is 0:
        cnt = 0
        for i in range(len(s1)):
            if s1[i] != s2[i]: 
                cnt += 1
                if cnt > 1: return False
        return True
    else: # i.e., if len_diff is 1
        for i in range(len(s1)):
            if s1[i] != s2[i]:
                s2.pop(i)
                if s1[i] != s2[i]: return False
        return True

print(OneEditApart("cat", "dog"))
print(OneEditApart("cat", "cats"))
print(OneEditApart("cat", "cut"))
print(OneEditApart("cat", "cast"))
print(OneEditApart("cat", "at"))
print(OneEditApart("cat", "acts"))

Python으로 풀어보았습니다.

Python으로 풀었는데 다 풀고나니 위의 풀이들과 별 다른 것은 없네요

def change(s1,s2):

    falsecheck=0
    for i in range(len(s1)):
        if s1[i]!=s2[i]:
            falsecheck+=1
    if falsecheck<=1:
        return True
    else : 
        return False

def plus(s1,s2):
    alphabet='abcdefghijklmnopqrstuvwxyz'
    if len(s1)<len(s2):
        small=s1 ; big=s2
    else:
        small=s2 ; big=s1
    for i in range(len(small)+1):
        for j in alphabet:
            changesmall=small[:i]+j+small[i:]
            if changesmall==big:
                return True
    return False

def OneEditApart(s1,s2):
    if len(s1)==len(s2):
        return change(s1,s2)
    elif abs(len(s1)-len(s2))==1:
        return plus(s1,s2)
    else:
        return False

print OneEditApart("cat", "dog")
print OneEditApart("cat", "cats")
print OneEditApart("cat", "cut") 
print OneEditApart("cat", "cast")
print OneEditApart("cat", "at") 
print OneEditApart("cat", "acts")

python으로 하니 순서가 바뀌는 'acts' 같은 경우 때문에 생각보다 어렵네요,,, character 가 같을때랑 character 숫자 번호가 같거나 +-1씩 차이날때만 count하여 구했습니다...

def comp(word1, word2):
    c1 = 0
    match = 0
    flag = 0
    for ch1 in word1:
        c2 = 0
        for i in range(0, len(word2)):
            if (ch1 == word2[i]) and (c1 == c2 or c1 == c2+1) and (flag ==0):
                print (c1, c2, ch1, word2[i], match, flag)
                match += 1
                break
            if (ch1 == word2[i]) and (c1 == c2 or c1 == c2-1):
                print (c1, c2, ch1, word2[i], match, flag)
                match += 1
                flag = 1
                break
            c2 += 1
        c1 += 1        

    if (match >= len(word1)-1) and (match >= len(word2)-1) :        
        return 'true'
    else:
        return 'false'

print(comp('cat', 'dog'))
print(comp('cat', 'cats'))
print(comp('cat', 'cut'))
print(comp('cat', 'cast'))
print(comp('cat', 'at'))
print(comp('cat', 'acts'))

python 입니다. 2글자 이상 일치하면 true로 판단하도록 작성해봤습니다.

# -*- coding: utf-8 -*- 
import unittest

def OneEditApart(s1, s2, count=0):
  # 글자 왼쪽 끝을 기준으로 비교 
  for i in range(min(len(s1),len(s2))):
    if s1[i] == s2[i]: count += 1
  if count < 2 : count = 0

  # 글자 오른쪽 끝을 기준으로비교   
  if len(s1) < len(s2) and count < 2:
    for i in range(len(s1)):
      if s1[i] == s2[i+1]: count += 1
  elif len(s1) > len(s2) and count < 2:
    for i in range(len(s2)):
      if s1[i+1] == s2[i]: count += 1

  if count >= 2 : return "true"
  else : return "false"

class Test(unittest.TestCase):
  def test1(self):
    self.assertEqual('false', OneEditApart("cat", "dog"))
    self.assertEqual('true', OneEditApart("cat", "cats"))
    self.assertEqual('true', OneEditApart("cat", "cuts"))
    self.assertEqual('true', OneEditApart("cat", "cast"))
    self.assertEqual('true', OneEditApart("cat", "at"))
    self.assertEqual('true', OneEditApart("cat", "ca"))
    self.assertEqual('false', OneEditApart("cat", "acts"))

if __name__ == "__main__":
  unittest.main()

foo( 'caat', 'tcaat' )
foo( 'cat', 'cct' )
foo( 'cat', 'caa' ) ...
처음에는 위와 같은 문자열의 중복을 생각하지 못해 수월하게 만들었는데,
다시 중복을 고려해서 짜려니 코드도 지저분해지고 시간도 생각보다 오래걸렸네요..

coding by python beginner

def c( a, b, differ ):
    if len(differ) == 1:
        return True if a == b.replace( differ[0], '' ) else False
    elif len(differ) == 0:
        rs = []
        for i in range( len(b) ):
            if b[i] not in rs and a[len(rs)] == b[i]: rs.append(b[i])
        return True if a == ''.join(rs) else False
    else:
        return False


def d( a, b, differ ):
    if len(differ) > 0:
        return False
    else:
        for i in range( len(a) ):
            if b == a[:i] + a[i+1:]: return True
        return False


def u( a, b, differ ):
    if len(differ) > 0:
        for i in range( len(a) ):
            if b == a[:i] + differ[0] + a[i+1:]: return True
        return False
    else:
        if a == b: return True
        else:
            for i in range( len(b) ):
                b1 = b[:i] + b[i+1:]
                d1 = [x for x in b1 if x not in a]
                if d(a, b1, d1): return True
            return False

def foo( a, b ):
    differ = [x for x in b if x not in a]
    if   len(a) + 1 == len(b): return c( a, b, differ )
    elif len(a) - 1 == len(b): return d( a, b, differ )
    elif len(a)     == len(b): return u( a, b, differ )
    else: return False

print( foo( 'cat', 'dog' ) )
print( foo( 'cat', 'cats' ) )
print( foo( 'cat', 'cut' ) )
print( foo( 'cat', 'cast' ) )
print( foo( 'cat', 'at' ) )
print( foo( 'cat', 'acts' ) )

펄입니다

use latest;
unless(length $ARGV[0]<length $ARGV[1]){my $t=$ARGV[0];$ARGV[0]=$ARGV[1];$ARGV[1]=$t}
my @s1=$ARGV[0]=~/./sg;my($s2,$cnt)=($ARGV[1],0);
for (@s1){if($s2=~/$_/){$s2=~s/$_//;$cnt++}}
if($cnt==@s1){say "true"}else{say "false"}

C#으로 작성했습니다.

        public bool IsOneEditApart(string a, string b)
        {
            var count = 0;
            var large = a.Length > b.Length ? a : b;
            var small = a.Length > b.Length ? b : a;
            if (large.Length == small.Length)
            {
                for (int i = 0; i < large.Length; i++)
                    if (large[i] != small[i] && ++count > 1)
                        return false;
            }
            else if (large.Length > small.Length)
            {
                var i = 0;
                while (i < small.Length)
                {
                    if (large[i + count] != small[i])
                    {
                        if (++count > 1) return false;
                    }
                    else i++;
                }
            }
            else return false;
            return true;
        }

#데이터
#처리
def checkRemoval(bs, ss):
    for i in range(len(bs)):            
        t = bs[:i]+bs[i+1:] 
        if ss == t: return True
    return False
def checkReplace(s1, s2):
    for i in range(len(s1)):
        t1 = s1[:i]+s1[i+1:]            
        t2 = s2[:i]+s2[i+1:]            
        if t1 == t2: return True       
    return False
def OneEditApart(s1, s2):
    if len(s1) > len(s2):               
        return checkRemoval(s1, s2)
    elif len(s1) < len(s2):             
        return checkRemoval(s2, s1)     
    else:                               
        return checkReplace(s1, s2)
#입출력
print(OneEditApart("cat", "dog"))
print(OneEditApart("cat", "cats"))
print(OneEditApart("cat", "cut"))
print(OneEditApart("cat", "cast"))
print(OneEditApart("cat", "at"))
print(OneEditApart("cat", "acts"))

python입니다: 삽입/제거/교환 모두 한글자씩 제거해놓고 비교하면 될 것 같아서 이렇게 작성해봤습니다.

# oneeditaprt.py
# http://codingdojang.com/scode/445

import unittest

def OneEditApart(s1, s2):
    for i in range(max(len(s1), len(s2))):
        k1 = s1[:i] + s1[i+1:]
        k2 = s2[:i] + s2[i+1:]
        if k1 == k2 or k1 == s2 or k2 == s1:
            return True
    return False

class OneEditApartTest(unittest.TestCase):
    def test_oneeditapart(self):
        self.assertFalse(OneEditApart("cat", "dog"))
        self.assertTrue(OneEditApart("cat", "cats"))
        self.assertTrue(OneEditApart("cat", "cut"))
        self.assertTrue(OneEditApart("cat", "cast"))
        self.assertTrue(OneEditApart("cat", "at"))
        self.assertFalse(OneEditApart("cat", "acts"))

    def test_customtest(self):
        self.assertTrue(OneEditApart("caat", "tcaat"))
        self.assertTrue(OneEditApart("cat", "cct"))
        self.assertTrue(OneEditApart("cat", "caa"))

if __name__ == '__main__':
    unittest.main()

Ruby

diff = ->a,b { a,b = a[1..-1],b[1..-1] while a[0] == b[0] && a && b; [a, b] }
one_apart = ->a,b { diff[*diff[a, b].map(&:reverse)].map(&:size).max < 2 }

Test

expect(one_apart["cat","dog"]).to eq false 
expect(one_apart["cat","cats"]).to eq true 
expect(one_apart["cat","cut"]).to eq true 
expect(one_apart["cat","cast"]).to eq true 
expect(one_apart["cat","at"]).to eq true 
expect(one_apart["cat","acts"]).to eq false 

비교하려는 문자의 길이의 차이가 1이내인 경우에 검사하는데요, s1 이 한글자 더 긴 경우에는 삭제해서 같은지, 즉 한 글자씩 뺀 문자열이 s2와 같은지 검사하고 길이가 같은 경우에는 한글자만 교체해서 같은지 검사하므로 각각 같은 위치 글자를 빼서 같은지 검사합니다. s1이 한글자 짧은 경우는 s2, s1으로 비교했을 때 s2가 한글자 긴 케이스와 동일하고 그외의 경우는 모두 False 입니다.

def OneEditApart(s1, s2):
    l1 = len(s1)
    l = l1 - len(s2)
    if l is 1:
        for i in range(l1):
            if s1[0:i] + s1[i+1:] == s2:
                return True
    if l is 0:
        for i in range(l1):
            if s2[0:i] + s2[i+1:] == s1[0:i] + s1[i+1:]:
                return True
    if l is -1:
        return OneEditApart(s2, s1)
    return False


samples = [x.split() for x in """cat dog
cat cats
cat cut
cat cast
cat at
cat acts""".split('\n')]

for s in samples:
    print(s, OneEditApart(*s))

python 3.5

def one_editor_apart(string1, string2):
      short = (len(string1)>=len(string2)) if len(string2) else len(string1)
      longer = (len(string2)>len(string1)) if len(string1) else len(string2)
       count = 0
       if(longer-short>1):
           return false
      else:
          string1 = list(string1)
          string2 = list(string2)
          string1.sort()
          string2.sort()
          for i in range(short):
              if(string1[i]==string2[i]):
                  count+=1
          return short==count




 print(one_editor_apart("cat", "at"))
 print(one_editor_apart("ata", "at"))

C++ 로 일단 풀어봤습니다
그 말이 그 말이겠지만 저는 약간 확률을 조금 이용했습니다, 식은 아래와 같습니다

(단어일치 수/MaxStringLen)*100 의 결과 값이 50%이상이면 두 단어는 유사하다
(한글자를 수정하거나 삽입 또는 제거하면 일치)

bool Calculator_Percent(int Longger_Len, char *temp_s1, char *temp_s2)
{
    double Correct_Counter = 0.0;
    double Percent = 0;

    for (int i = 0; i < Longger_Len; i++)
    {
        if (temp_s1[i]==temp_s2[i])
        {
            Correct_Counter++;
        }
    }

    **Percent = (Correct_Counter / Longger_Len) * 100; 
**  return (Percent >= 50);
}

**
bool OneEditApart(char *s1, char *s2)**
{
    int Longger_Len = strlen(s1) >= strlen(s2) ? strlen(s1) : strlen(s2); //store longer string len
    bool result = false;

    char *temp_s1 = new char[Longger_Len + 1];
    strcpy_s(temp_s1, strlen(s1) + 1, s1);

    char *temp_s2 = new char[Longger_Len + 1];
    strcpy_s(temp_s2, strlen(s2) + 1, s2);

    if (Calculator_Percent(Longger_Len, temp_s1, temp_s2))
    {
        result = true;
    }
    else if (!(strlen(temp_s1) == strlen(temp_s2)) )
    {

        char *shorter = strlen(temp_s1) > strlen(temp_s2) ? temp_s2 : temp_s1; //select short string

        for (int i = strlen(shorter); i > 0; i--)
        {
            shorter[i] = shorter[i - 1];
        }
        shorter[0] = '\0';

        if (Calculator_Percent(Longger_Len, temp_s1, temp_s2))
        {
            result= true;
        }
        else
        {
            result= false;
        }
    }

    delete[] temp_s1;
    delete[] temp_s2;

    return result;
}

Python 3.4.4

def OneEditApart(target_message, message):
    for j in range(0, len(target_message)):
        try:
            if target_message[0:j+1] == message[(j+1)*-1:]:
                return True

            if target_message[0:j+1] == message[0:j+1]:
                return True

            if target_message[(j+1)*-1:] == message[(j+1)*-1:]:
                return True
        except IndexError as err: 
            return False
    return False

//java 가 없어서 올립니다. 추가나 삭제나 동일하기에 길이가 작은값에 공백값 넣어주고 길이 같에해서 비교하고 같을때는 그냥 비교 하고...

private static void Test() {
        System.out.println("is true = " + OneEditApart("cat", "dog"));
        System.out.println("is true = " + OneEditApart("cat", "cats"));
        System.out.println("is true = " + OneEditApart("cat", "cut"));
        System.out.println("is true = " + OneEditApart("cat", "cast"));
        System.out.println("is true = " + OneEditApart("cat", "at"));
        System.out.println("is true = " + OneEditApart("cat", "acts"));
    }

    private static boolean OneEditApart(String string, String string2) {
        if (string.length() == string2.length()) { // 스트링 수 같을 때
            int isCorrectNum = 0;
            for (int i = 0; i < string.length(); i++) {
                if (string.charAt(i) == string2.charAt(i)) {
                    isCorrectNum++;
                }
            }
            if (isCorrectNum >= string.length() - 1) {
                return true;
            } else {
                return false;
            }
        } else if (string.length() > string2.length()) {
            for (int i = 0; i < string.length(); i++) {
                if (i >= string2.length() || string.charAt(i) != string2.charAt(i)) {
                    StringBuilder sb = new StringBuilder(string2);
                    string2 = sb.insert(i, ' ').toString();
                    return OneEditApart(string, string2);
                }
            }
          } else if (string.length() < string2.length()) {
            for (int i = 0; i < string2.length(); i++) {
                if (i >= string.length() || string.charAt(i) != string2.charAt(i)) {
                    StringBuilder sb = new StringBuilder(string);
                    string = sb.insert(i, ' ').toString();
                    return OneEditApart(string, string2);
                }
            }
        }
        return false;
    }

package javaCoding;

import java.util.Scanner;

/ * 비슷한 문자 찾기 알고리즘! 자바로 만들 었습니다. * * * @author pc02 /

public class Coding010 {

public static void main(String[] args) {
    Scanner input2=new Scanner(System.in);
    Scanner input1=new Scanner(System.in);


    System.out.println("원하는 값을 입력하세요.");
    String a=input1.nextLine();


    System.out.println("비교 값을 입력하세요.");
    String a2=input2.nextLine();



    System.out.println(AAA(a,a2));
}

public static boolean AAA(String a,String b){
    String ss="";
    String[] b2;
    String sum="";
    b2=b.split("");
    boolean falg=false;

    //수정 알고리즘
    for (int i = 0; i < b2.length; i++) {
        //기존 값 저장
        ss=b2[i];
        for (int j = 0; j < 128; j++) {
            char jj=(char)j;    
            //System.out.println(jj);
            //아스키코드 0~128 for문으로 넣기
            b2[i]=jj+"";

            for (int k = 0; k < b2.length; k++) {           
                //결과 합치기.
                sum=sum+b2[k];

            }

            //결과값 계속 비교.
            if(a.equals(sum.trim())){
                //같은게 있으면 true
                falg=true;
            }
            //sum 값 털기.
            sum="";
        }
        //b2[i] 값 털기.
        b2[i]=ss;
    }

    //제거 알고리즘
    for (int i = 0; i < b2.length; i++) {
        ss=b2[i];
        b2[i]="";

        for (int j = 0; j < b2.length; j++) {               
            sum=sum+b2[j];          
        }

        if(a.equals(sum.trim())){
            falg=true;
        }
        sum="";
        b2[i]=ss;
    }


    //추가 알고리즘.
    for (int i = 0; i < 128; i++) {
        char jj=(char)i;

        for (int j = 0; j < b2.length+1; j++) {
            sum=b.substring(0, j)+jj+b.substring(j);
            if(a.equals(sum.trim())){
                falg=true;
            }
            sum="";
        }   
    }

    return falg;
}

}

#한개의 문자를 삽입, 제거, 변환 -> True
import copy

a=input('word1 : ')
b=input('word2 : ')

#a와 b 리스트 생성
listA=[]
listB=[]
for k in range(len(a)):
    listA.append(a[k])
for k in range(len(b)):
    listB.append(b[k])

#동일 길이의 리스트 동일성 판별 -> 완전 동일하면 True
def countA(list1, list2):
    if len(list1)!=len(list2):
        print('길이가 같지 않습니다.')
        return False
    else:
        num=len(list1)
    count=0
    for i in range(num):
        if list1[i]!=list2[i]:
            count+=1
    if count==0:
        return True
    else:
        return False

#동일 길이의 리스트 유사성 판별 -> 한 글자 다르면 True
def countB(list1, list2):
    if len(list1)!=len(list2):
        print('길이가 같지 않습니다.')
        return False
    else:
        num=len(list1)
    count=0
    for i in range(num):
        if list1[i]!=list2[i]:
            count+=1
    if count==1:
        return True
    else:
        return False

def edit():

    #단어길이 차이가 2 이상
    if abs(len(a)-len(b))>=2:
        return False

    #삽입 & 제거
    if abs(len(a)-len(b))==1:
        n=min(len(a), len(b))
        if len(listA)==n:
            main=listA
            sub=listB
        elif len(listB)==n:
            main=listB
            sub=listA
        else:
            print('그럴리가...')
            print(main, sub)
        main1=copy.copy(main)
        sub1=copy.copy(sub)
        #print(main1, sub1)
        for k in range(n+1):
            main=copy.copy(main1)
            sub=copy.copy(sub1)
            sub.remove(sub[k])
            #print(main, sub, n+1, k)
            if countA(main, sub)==True:
                return True
        return False

    #변환
    if abs(len(a)-len(b))==0:
        if countB(listA, listB)==True:
            return True
        else:
            return False

print(bool(edit()))

def OneEditApart(a,b):
    c=[len(a),len(b),""]
    if abs(c[0]-c[1])>=2 : return False
    if c[0] < c[1]:
        c[0] = len(b)
        c[1] = a[:]
        c[2] = b[:]
    elif c[0] > c[1]:
        c[0] = len(a)
        c[1] = b[:]
        c[2] = a[:]
    else :
        c[0] = len(a)
        c[1] = a[:]
        c[2] = b[:]

    if abs(len(a)-len(b)) >=1 :
        for i in range(c[0]):
            aa=list(c[1])
            bb=list(c[2])
            del bb[i]
            if aa==bb :
                return True
    else:
        for i in range(c[0]):
            aa=list(c[1])
            bb=list(c[2])
            del bb[i],aa[i]
            if aa==bb :
                return True 

    return False
print(OneEditApart("cat", "dog"))
print(OneEditApart("cat", "cats"))
print(OneEditApart("cat", "cut"))
print(OneEditApart("cat", "cast"))
print(OneEditApart("cat", "at"))
print(OneEditApart("cat", "acts"))

Python 3.5.2

Python3로 작성하였고 데코레이터를 이용해 결과를 출력해보았습니다.

def display(func):
    def wrapFunc(A, B):
        print(func.__name__, (A, B), "=", func(A, B))
    return wrapFunc

@display
def OneEditApart(A, B):
    nA, nB = len(A), len(B)
    for i in range(min(nA, nB)):
        if A[i] != B[i]:
            if nA > nB:
                return A[i+1:] == B[i:]
            elif nA < nB:
                return A[i:] == B[i+1:]
            return A[i+1:] == B[i+1:]
    return A[:i] == B[:i]

# Test Case
OneEditApart("cat", "dog")
OneEditApart("cat", "cats")
OneEditApart("cat", "cut")
OneEditApart("cat", "cast")
OneEditApart("cat", "at")
OneEditApart("cat", "acts")

결과

OneEditApart ('cat', 'dog') = False
OneEditApart ('cat', 'cats') = True
OneEditApart ('cat', 'cut') = True
OneEditApart ('cat', 'cast') = True
OneEditApart ('cat', 'at') = True
OneEditApart ('cat', 'acts') = False

def OneEditApart(a, b):
    if abs(len(a) - len(b)) > 1:
        return False
    if len(b) < len(a):
        a, b = b, a
    for x, xv in enumerate(a):
        if xv == b[x]:
            pass
        else:
            ti = list(b)
            ti.insert(x, xv)
            td = list(b)
            del td[x]
            tr = list(b)
            tr[x] = xv
            return a == ''.join(ti) or a == ''.join(td) or a == ''.join(tr)
    return True

print('OneEditApart("cat", "dog"): %s' % OneEditApart("cat", "dog"))
print('OneEditApart("cat", "cats"): %s' % OneEditApart("cat", "cats"))
print('OneEditApart("cat", "cut"): %s' % OneEditApart("cat", "cut"))
print('OneEditApart("cat", "cast"): %s' % OneEditApart("cat", "cast"))
print('OneEditApart("cat", "at"): %s' % OneEditApart("cat", "at"))
print('OneEditApart("cat", "acts"): %s' % OneEditApart("cat", "acts"))

Python 3.5.2에서 작성하였습니다.

bool OneEditApart(char s1, char s2) { int i, cnt = 0; int gap = strlen(s1)-strlen(s2); if (gap == 0) { for (i = 0; i < strlen(s1); i++) { if (s1[i] != s2[i]) cnt++; } if (cnt > 1) return false; else return true; } else if (gap == 1) { for (i = 0; i < strlen(s2); i++) { if ((s1[i+cnt] != s2[i]) && (cnt == 1)) return false; else if ((s1[i+cnt] != s2[i]) && (cnt == 0)) cnt++; else continue; } return true; } else if (gap == -1) { for (i = 0; i < strlen(s1); i++) { if ((s1[i] != s2[i+cnt]) && (cnt == 1)) return false; else if ((s1[i] != s2[i+cnt]) && (cnt == 0)) cnt++; else continue; } return true; } else return false; }

def one_edit_apart(s1,s2):
    if len(s1) < len(s2):
        for x in range(len(s2)):
            if s2[:x]+s2[x+1:] == s1:
                return True
    elif len(s1) == len(s2):
        for x in range(len(s1)):
            if s1[x] != s2[x] and s1[:x]+s1[x+1:] == s2[:x]+s2[x+1:]:
                return True
    else:
        for x in range(len(s1)):
            if s1[:x] + s1[x+1:] == s2:
                return True
    return False

print(one_edit_apart('cat', 'dog'))
print(one_edit_apart('cat', 'cats'))
print(one_edit_apart('cat', 'cut'))
print(one_edit_apart('cat', 'cast'))
print(one_edit_apart('cat', 'at'))
print(one_edit_apart('cat', 'acts'))

#### 2016.12.30 D-419 ####

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

bool OneEditApart(char* s1, char* s2);
void main() {
    printf("%s\n", OneEditApart("cat", "dog") ? "true" : "false");
    printf("%s\n", OneEditApart("cat", "cats") ? "true" : "false");
    printf("%s\n", OneEditApart("cat", "cut") ? "true" : "false");
    printf("%s\n", OneEditApart("cat", "cast") ? "true" : "false");
    printf("%s\n", OneEditApart("cat", "at") ? "true" : "false");
    printf("%s\n", OneEditApart("cat", "acts") ? "true" : "false");
}

bool OneEditApart(char* s1, char* s2) {
    if(strlen(s1) == strlen(s2)) {
        int size = 0;
        int count = 0;
        size = strlen(s1);
        for(int i=1 ; i<=size ; i++) {
            if(!strcmp(s1, s2)) continue;
            else {
                count++;
                s1++;
                s2++;
            }
        }
        if(count<=2)
            return true;
    }
    else if(strlen(s1) - strlen(s2) == 1 ||  strlen(s2) - strlen(s1) == 1){
        int size = 0;
        char s_temp1[10];
        char s_temp2[10];
        if(strlen(s1) > strlen(s2)) {
            strcpy(s_temp1, s1);
            strcpy(s_temp2, s2);
            size = strlen(s1);
        }
        else  {
            size = strlen(s2);
            strcpy(s_temp1, s2);
            strcpy(s_temp2, s1);
        }
        char temp[10];
        for(int i=0;i<size;i++) {
            strcpy(temp, s_temp1);
            memmove(temp + i, temp+i+1, sizeof(temp)-1);
            if(!strcmp(temp, s_temp2)) {
                return true;
            }
        }
    }

    return false;
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/* 
 * 한개의 문자를 삽입, 제거, 변환을 했을때 s1, s2가 동일한지를 판별하는 OneEditApart 함수를 작성하시오.
 * 
 * 두 단어의 글자차이가 2이상나면 위의 함수로는 모두 false가 난다.
 * 차이가 1이면 앞에서부터 하나씩 조사하여 차이가 1 이면 제거했을 때 같은 문자가 될 수 있다.
 * 차이가  0이면 앞에서부터 하나씩 조사하여 차이가 1 이하가나면 같은 문자이거나 변환했을 때 같은 문자가 될 수 있다.

 * null을 주면 프로그램을 멈추게 하고 싶었는데 exception오류로 멈춰지네요. 그래도 결과는 잘 나올겁니다...
 */
public class check {

    public static void main(String[] args) {
        String[] s12 = new String[2];
        BufferedReader read = new BufferedReader(new InputStreamReader(System.in));
        while(true){
            try {
                s12 = read.readLine().split(" ");

                if(s12 == null)
                    break;

                if(OneEditApart(s12[0], s12[1]))
                    System.out.println(s12[0]+", "+s12[1]+" = "+true);
                else
                    System.out.println(s12[0]+", "+s12[1]+" = "+false);

            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try {
            read.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    static boolean OneEditApart(String s1, String s2){
        String[] s1_split = new String[s1.length()];
        String[] s2_split = new String[s2.length()];
        int j = 0;

        s1_split = s1.split("");
        s2_split = s2.split("");

        if(Math.abs((s1.length()-s2.length())) > 1)
            return false;
        else if(Math.abs((s1.length()-s2.length())) == 1){
            if(s1.length() > s2.length())
                return compare(s1_split,s2_split);
            else
                return compare(s2_split,s1_split);
        }
        else{   
            for(int i = 0; i<s1.length();i++)
                if(s1_split[i].equals(s2_split[i]))
                    j++;
            if(j >= s1.length()-1)
                return true;
            else
                return false;
        }
    }
    static boolean compare(String[] s1, String[] s2){
        int l = 0;
        for(int k = 0; k < s1.length; k++){
            if(s1[k].equals(s2[l])){
                l++;
            }
        }
        if(l == s2.length)
            return true;
        else
            return false;
    }

}

import java.util.Scanner;
import static java.lang.System.in;
import static java.lang.System.out;

public class OneEditApart {

    public static void main(String[] args) {
        Scanner sc = new Scanner(in);
        String a = sc.next();
        String b = sc.next();
        out.println("" + oneEditApart(a, b));
    }

    private static boolean oneEditApart(final String a, final String b) {
        if (Math.abs(a.length() - b.length()) > 1) return false;

        String[] e = a.split("");
        String[] f = b.split("");

        int k = 0;
        int d = 0;

        for (int i = 0; i < f.length; i++) {
            for (int j = k; j < e.length; j++) {
                if (f[i].equals(e[j])) {
                    out.println("Same " + f[i] + " " + e[j]);
                    k = j + 1;
                    break;
                } else {
                    d = d + 1;
                    out.println("Diff " + f[i] + " " + e[j]);
                    if (e.length == f.length) {
                        k = j + 1;
                        break;
                    }
                }
            }
        }
        return d > 1 ? false : true;
    }
}

def OneEditApart(s1, s2):
    if len(s1)+1 == len(s2):  #삽입  , 제거(s2, s1)
        if s1[0:len(s1)] == s2[0:len(s1)]:
            print("삽입 true")

        for i in range(len(s1)):
           if s1[i] != s2[i]:
               if s1[0:i] == s2[0:i] and s1[i:]== s2[i+1:]:
                   print("삽입 ture")
               else: print("false")
               break



    elif len(s1) == len(s2)+1:
        if s1[0:len(s2)] == s2[0:len(s2)]:
            print("제거 true")

        for i in range(len(s2)):
           if s1[i] != s2[i]:
               if s1[0:i] == s2[0:i] and s1[i+1:]== s2[i:]:
                   print("제거 ture")
               else: print("false")
               break





    elif len(s1) == len(s2):  #변환
         for i in range(len(s1)):
           if s1[i] != s2[i]:
               if s1[0:i] == s2[0:i] and s1[i+1:]== s2[i+1:]:
                   print("변환 true")
               else: print("false")
               break

    else: print("false")       



사실 도저히 못풀겠어서 다른분이 한것을 보고 이해한 후에
일주일후 머리 리셋시키고 풀어봤네요

Python 3으로 풀었습니다.

def OneEditApart(s1, s2):
    if len(s1) > len(s2):
        temp = s1
        s1 = s2
        s2 = temp

    # 변환
    if len(s1) == len(s2):
        return 1 >= len([pair for pair in zip(s1, s2) if pair[0] != pair[1]])

    # 추가 or 삭제
    elif len(s1) + 1 == len(s2):
        for i, c in enumerate(s1):
            if s2[i] != c:
                return s1[i:] == s2[i+1:]
        return True
    return False

    public static boolean OneEditApart(String str1, String str2) {
        String shorter = str1.length() <= str2.length() ? str1:str2;
        String longer = str1.length() <= str2.length() ? str2:str1;
        int cnt=0, i;

        if(longer.length()-shorter.length() > 1) return false;
        else if(longer.length() == shorter.length()) {
            for(i=0;i<shorter.length();i++) {
                if(longer.charAt(i) != shorter.charAt(i)) { cnt++; } 
                if(cnt>1) return false;
                }
            }
        else {
            for(i=0;i<shorter.length();i++) {
                if(longer.charAt(i+cnt) != shorter.charAt(i)) { cnt++; i--; }
                if(cnt>1) return false;
            }
        }

        return true;
    }

def OneEditApart(s1, s2):
    if s1.find(s2) >= 0 or s2.find(s1) >= 0:
        return 'true'
    count = 0
    for idx2, char2 in enumerate(s2):
        for idx1, char1 in enumerate(s1):
            if idx2 >= idx1 and char1 == char2:
                count += 1
    if len(s1) < len(s2):
        if count == len(s1):
            return 'true'
    else:
        if count > 0:
            return 'true'
    return 'false'

print(OneEditApart('cat','dog'))
print(OneEditApart("cat", "cats"))
print(OneEditApart('cat','cut'))
print(OneEditApart('cat','cast'))
print(OneEditApart('cat','at'))
print(OneEditApart('cat','acts'))

def oneEditApart(s1, s2):
    if len(l1) < len(l2): 
        s1, s2 = s2, s1
    l1, l2 = len(s1), len(s2)  # l1 >= l2

    if l1 - l2 > 1: 
        return False

    if l1 == l2:
        diff = [s1[i] != s2[i] for i in range(l1)]
        return sum(diff) == 1

    p1, p2 = 0, 0
    chance = True
    while p1 < l1:
        if p2 >= l2 or s1[p1] != s2[p2]:
            if not chance:
                return False
            else:
                chance = False
                p1 += 1
        else:
            p1 += 1
            p2 += 1

    return True

C++입니다ㅜ.. ( 파이썬은 ... 코딩의 꽃인것 같네요..)

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

bool OneEditApart(string s1, string s2) {
    bool answer = false;
    string tmp1, tmp2;

    // s1을 제거하지 않고 비교
    tmp1 = s1;
    for (int j = 0; j < s2.size(); j++) {
        tmp2 = s2;
        j == 0 ? tmp2.erase(j, j + 1) : tmp2.erase(j, j);
        //cout << tmp1 << " <비교> " << tmp2 << endl;
        if (tmp1 == tmp2) {
            answer = true;
            break;
        }
    }
    // s2를 제거하지 않고 비교
    tmp2 = s2;
    if(!answer){
        for (int i = 0; i < s1.size(); i++) {
            tmp1 = s1;
            i == 0 ? tmp1.erase(i, i + 1) : tmp1.erase(i, i);
            //cout << tmp1 << " <비교> " << tmp2 << endl;
            if (tmp1 == tmp2) {
                answer = true;
                break;
            }
        }
    }
    // s1 s2을 하나씩 꺼내가면서 비교
    if(!answer){
        for (int i = 0; i < s1.size(); i++) {
            tmp1 = s1;
            i==0 ? tmp1.erase(i, i+1):tmp1.erase(i, i);
            for (int j = 0; j < s2.size(); j++) {
                tmp2 = s2;
                j==0?tmp2.erase(j, j + 1):tmp2.erase(j, j);
                //cout << tmp1 << " <비교> " << tmp2 << endl;
                if (tmp1 == tmp2) {
                    answer = true;
                    break;
                }
            }
        }
    }
    return answer;
}

int main() {
    OneEditApart("cat", "dog") ? puts("True") : puts("False");
    OneEditApart("cat", "cats") ? puts("True") : puts("False");
    OneEditApart("cat", "cut") ? puts("True") : puts("False");
    OneEditApart("cat", "cast") ? puts("True") : puts("False");
    OneEditApart("cat", "at") ? puts("True") : puts("False");
    OneEditApart("cat", "acts") ? puts("True") : puts("False");

    return 0;
}

코드가 굉장히 못생겼지만 키포인트는

• s1과 s2의 길이가 같을 경우는 s1의 문자들을 하나씩 update해서 비교하고
• s1이 s2보다 길이가 길 경우 s1의 문자를 하나씩 지워서 비교하고
• s1이 s2보다 길이가 짧을 경우 s2의 문자를 하나씩 s1에 넣어서 비교하면 됩니다.

const OneEditApart = (s1, s2) => {
  let result = false;
  s1 = s1.split('');

  if (s1.length === s2.length) {
    // update
    for (let i = 0; i < s2.length; i++) {
      for (let j = 0; j < s1.length; j++) {
        let tmp = s1[j];
        s1[j] = s2.charAt(i);
        if (s1.join('') === s2) {
          result = true;
        } 
        s1[j] = tmp;
      }
    }
  } else if (s1.length > s2.length) {
    // delete
    for (let i = 0; i < s1.length - 1; i++) {
      if (s1[i] + s1[i + 1] === s2) {
        result = true;
      }
    }
  } else {
    // insert
    for (let i = 0; i < s2.length; i++) {
      for (let j = 0; j <= s1.length; j++) {
        s1.splice(j, 0, s2.charAt(i));
        if (s1.join('') === s2) {
          result = true;
        } 
        s1.splice(j, 1);
      }
    }
  }

  console.log(result);
};

OneEditApart("cat", "dog");   // false
OneEditApart("cat", "cats");  // true
OneEditApart("cat", "cut");   // true
OneEditApart("cat", "cast");  // true
OneEditApart("cat", "at");    // true
OneEditApart("cat", "acts");  // false

def OnEditApart(tup):
    s1,s2=tup
    count=0
    if abs(len(s1)-len(s2))>1:
        return(False)
    s11=(s1,s2)[len(s1)<=len(s2)]
    s22=(s1,s2)[s1==s11]
    for x,y in enumerate(s11):
        if not count and x==len(s11)-1:
            break
        elif not count and y!=s22[x]:
            count+=1
        elif count:
            if len(s11)==len(s22) and y!=s22[x]:
                return(False)
            elif len(s11)!=len(s22) and  y!=s22[x-1]:
                return(False)
    return(True)

A=[("cat", "dog"),("cat", "cats"),("cat", "cut")
        ,("cat", "cast"),("cat", "at" ),("cat", "acts")]

for i in A:
    print(OnEditApart(i))

def oea(s1,s2):
    if abs(len(s1)-len(s2))>1:
        return False 

    elif len(s1)==len(s2):
        ind=0
        for x in range(len(s1)):
            if s1[x]==s2[x]:ind=ind+1
        if ind<len(s1)-1:return False
        else:return True

    elif len(s1)<len(s2):
        for y in range(len(s2)):
           if s2[:y]+s2[y+1:]==s1:return True
        return False

    elif len(s1)>len(s2):
        for z in range(len(s1)):
            if s1[:z]+s1[z+1:]==s2:return True
        return False

print(oea("cat", "dog")) 
print(oea("cat", "cats")) 
print(oea("cat", "cut"))  
print(oea("cat", "cast"))  
print(oea("cat", "at")) 
print(oea("cat", "acts")) 

파이썬 3.6

• 아이디어>
• s1, s2가 길이가 같을 때, 두 문자열의 동일 index문자를 순서대로 비교(변환 확인)
• 두 문자열의 길이가 다를 때, 두 문자열 길이를 공백문자를 이용해 임의로 같게하여 동일 index문자를 순서대로 비교하고 다른 문자열을 발견하면 해당 문자 index에 공백 문자를 넣어 두 문자의 길이를 같게하여 다시 동일 index문자를 순서대로 비교(삽입, 제거 확인)

def OneEditApart(s1, s2):
    n = 0
    s1_list, s2_list = list(s1), list(s2)
    if len(s1) == len(s2):
        print( "( %s , %s )"%(s1,s2))
        for i in zip(s1_list,s2_list):
            if i[0] == i[1]: n += 1
        if n == len(s1) - 1: print( " true" )
        else: print( " false" )
    else:
        if len(s1) > len(s2):
            print( "( %s , %s )"%(s1,s2))
            s2_list.append("' '")
            ziplist = list(zip(s1_list, s2_list))
            for i in ziplist:
                if i[0] != i[1]:
                    s2_list.insert(ziplist.index(i),' ')
                    s2_list.pop()
                    break
            for i in zip(s1_list,s2_list):
                if i[0] == i[1]: n += 1
            if n == len(s1)-1: print( " true")
            else: print( " false")                   
        else:
            print( "( %s , %s )"%(s1,s2))
            s1_list.append("' '")
            ziplist = list(zip(s1_list, s2_list))
            for i in ziplist:
                if i[0] != i[1]:
                    s1_list.insert(ziplist.index(i),' ')
                    s1_list.pop()
                    break
            for i in zip(s1_list,s2_list):
                if i[0] == i[1]:n += 1
            if n == len(s1): print( " true")
            else: print( " false")

if __name__ == "__main__":
    OneEditApart("cat", "dog")
    OneEditApart("cat", "cats") 
    OneEditApart("cat", "cut") 
    OneEditApart("cat", "cast") 
    OneEditApart("cat", "at")
    OneEditApart("cat", "acts")

*결과값

( cat , dog )
 false
( cat , cats )
 true
( cat , cut )
 true
( cat , cast )
 true
( cat , at )
 true
( cat , acts )
 false

# 파이썬
input_sample = (("cat", "dog"), ("cat", "cats"), ("cat", "cut"), ("cat", "cast"), ("cat", "at"), ("cat", "acts"))


def insert_s(s1, s2):
    alph = "abcdefghijklmnopqrstuvwxyz"
    inserted_list = []
    for m in range(len(s1)+1):
        for n in alph:
            inserted_s1 = s1[:m] + n + s1 [m:]
            if s2 == inserted_s1:
                return True


def change_s(s1, s2):
    alph = "abcdefghijklmnopqrstuvwxyz"
    changed_list = []
    for m in range(len(s1)):
        for n in alph:
            changed_s1 = s1[:m] + n + s1 [m+1:]
            if s2 == changed_s1:
                return True


def one_edit_apart(s1, s2):
    if change_s(s1, s2):
        return True
    elif insert_s(s1, s2):
        return True
    elif insert_s(s2, s1):
        return True
    else:
        return False


for m in input_sample:
    i, j = m[0], m[1]
    print(one_edit_apart(i, j))

def OneEditApart(s1, s2):
    c = list()
    if len(s1) == len(s2) + 1:
        for i in range(len(s1)):
            a = list(s1)
            a.pop(i)
            c.append(a == list(s2))
        return any(c)
    elif len(s1) == len(s2) - 1:
        for i in range(len(s2)):
            b = list(s2)
            b.pop(i)
            c.append(b == list(s1))
        return any(c)
    elif len(s1) == len(s2):
        for i in range(len(s1)):
            a = list(s1)
            b = list(s2)
            a.pop(i)
            b.pop(i)
            c.append(a == b)
        return any(c)
    else:
        return "false"

from itertools import combinations

def OneEditApart(a,b):
    if a==b:
        return True
    a_ord_list = []
    b_ord_list = []
    for str_a in a:
        a_ord_list.append(ord(str_a))
    for str_b in b:
        b_ord_list.append(ord(str_b))
    if len(a)==len(b) and a!=b:
        counter=0
        for k in range(len(a)):
            if a_ord_list[k]==b_ord_list[k]:
                counter+=1
        if counter>=len(a)-1:
            return True
        else:
            return False
    elif len(a)==len(b)-1:
        comb=combinations(b,len(a))
        for k in comb:
            string=''
            for g in k:
                string+=g
            if string==a:
                return True
                break
        return False
    elif len(b) == len(a) - 1:
        comb = combinations(a, len(b))
        for k in comb:
            string = ''
            for g in k:
                string += g
            if string == b:
                return True
                break
        return False
    else:
        return False

print(OneEditApart("cat","dog"))
print(OneEditApart("cat","cats"))
print(OneEditApart("cat","cut"))
print(OneEditApart("cat","cast"))
print(OneEditApart("cat","at"))
print(OneEditApart("cat","acts"))

def OneEditApart(string1, string2) :

    length = abs(len(string1)-len(string2))
    str1_sub, str2_sub = [], []

    if length >= 2 :
        print('false')
    else :
        str1_list, str2_list = list(string1), list(string2)
        for i in range(0 , min(len(str1_list), len(str2_list))) :
            if str1_list[i] != str2_list[i] :
                str1_sub.append(str1_list[i])
                str2_sub.append(str2_list[i])
            else :
                continue

        if len(str1_list) != len(str2_list) and len(str1_list) > len(str2_list) :
            str1_sub.append(str1_list[len(str1_list)-1])
        elif len(str1_list) != len(str2_list) and len(str1_list) < len(str2_list) :
            str2_sub.append(str2_list[len(str2_list)-1])

        str1_list = str1_sub
        str2_list = str2_sub

    if len(str1_list) == len(str2_list) == 1 :
        print('ture')
    elif len(str1_list) == len(str2_list) == 2 :
        if str1_list[0] in str2_list and str1_list[1] in str2_list :
            print('true')
    elif len(str1_list) != len(str2_list) :
        if len(str1_list) == max(len(str1_list), len(str2_list)) :
            if ''.join(str2_list) in ''.join(str1_list) :
                print('true')
            else :
                print('false')
        else :
            if ''.join(str1_list) in ''.join(str2_list) :
                print('true')
            else :
                print('false')
    else :
        print('false')

Swift입니다.

두 문자열의 길이가 같은 경우, 한 문자가 변경된 것이고, 같지 않은 경우는 추가 혹은 삭제가 된것으로, 추가/삭제는 하나의 함수로, 변경도 하나의 함수로 작성했습니다.

import Foundation

func checkInsert(_ sLonger: String, _ sShorter: String) -> Bool {
    var result = true

    if sLonger.contains(sShorter) == false {
        let shorterCount = sShorter.count
        let longerCount = sLonger.count
        let shorter = Array(sShorter)
        let longer = Array(sLonger)

        for i in 0..<shorterCount {
            if longer[i] != shorter[i] {
                result = sShorter.contains(String(longer[0..<i])) && sShorter.contains(String(longer[(i+1)..<longerCount]))
                break;
            }
        }
    }
    return result
}

func checkChange(_ s1: String, _ s2: String) -> Bool {
    var count = 0
    let s1Array = Array(s1)
    let s2Array = Array(s2)
    for i in 0..<s1.count {
        if s1Array[i] != s2Array[i] {
            count += 1
        }
    }
    return count == 1    
}

func OneEditAprt(_ s1: String, _ s2: String) -> Bool {
    var result = false
    let s1Count = s1.count 
    let s2Count = s2.count 

    if abs(s1Count - s2Count) < 2 {
        if s1Count > s2Count {
            result = checkInsert(s1, s2)
        } else if s1Count == s2Count {
            result = checkChange(s1, s2)
        } else {
            result = checkInsert(s2, s1)
        }
    } 
    return result 
}

print( OneEditAprt("cat", "dog") )      // false
print( OneEditAprt("cat", "cats") )     // true
print( OneEditAprt("cat", "cut") )      // true
print( OneEditAprt("cat", "cast") )     // true
print( OneEditAprt("cat", "at") )       // true
print( OneEditAprt("cat", "acts") )     // false

object Main extends App {
    // 삽입 삭제 교체 상관 없이 다른 문자열의 개수만 파악하여 계산
    def OneEditApart(s1:String, s2:String):Boolean = {
        def loop(str1:String, str2:String):Boolean = {
            var temp = str2
            var diff = 0
            for(x <- 0 until str1.length){
                if(!temp.isEmpty && str1(x) == temp.head){
                    temp = temp.tail
                    diff += 1
                }
            }
            if(str1.length - diff <= 1) true
            else false
        }
        if(s1.length >= s2.length){
            loop(s1, s2)
        }
        else{
            loop(s2, s1)
        }
    }
    println(OneEditApart("cat", "dog"))
    println(OneEditApart("cat", "cats"))
    println(OneEditApart("cat", "cast"))
    println(OneEditApart("cat", "acts"))

}

public class SimilarWord {

    public static boolean OneEditApart(String s1, String s2){

        char[] s1Array = s1.toCharArray();
        char[] s2Array = s2.toCharArray();

        if(s1Array.length == s2Array.length){ // 글자수가 같으면 한개 변환 가능할 시 true
            int count = 0;

            for(int i=0; i< s1Array.length; i++){
                if(count > 1){
                    return false;
                }
                if(s1Array[i] == s2Array[i]){
                    continue;
                }else{
                    count++;
                }
            }
            return true;
        }else{ // 글자수가 다르면 한개 제거 가능할시 true
            int count = 0;

            int minLength = 0;
            int flag = 0;

            if(s1Array.length < s2Array.length){
                minLength = s1Array.length;
                flag = 2; // 2가 더 큼
            }else{
                minLength = s2Array.length;
                flag = 1; // 1이 더 큼
            }

            for(int i=0; i < minLength; i++){
                if(count > 1){
                    return false;
                }
                if(s1Array[i] == s2Array[i]){
                    continue;
                }else{
                    count++;
                    if(flag == 1){
                        for(int j=i; j<s1Array.length-1; j++){
                            s1Array[j] = s1Array[j+1];
                        }
                    }else{
                        for(int j=i; j<s2Array.length-1; j++){
                            s2Array[j] = s2Array[j+1];
                        }
                    }
                }
            }
            return true;
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println(OneEditApart("cat", "dog"));
        System.out.println(OneEditApart("cat", "cats"));
        System.out.println(OneEditApart("cat", "cut"));
        System.out.println(OneEditApart("cat", "cast"));
        System.out.println(OneEditApart("cat", "at"));
        System.out.println(OneEditApart("cat", "acts"));
    }

}

def OneEditApart(s1,s2): # s1, s2 are words
    # 한개의 문자를 삽입,제거,변환
    count = 0

    lst1 = list(s1)
    lst2 = list(s2)

    #삽입의 경우
    #뒤에서 하나를 제거했을 때 같아지는지 확인
    if len(s1) < len(s2):
        string = ''
        for idx in range(len(lst2)):
            # s1에 존재하지 않을 때, 제거하면 s1이 되는지 확인
            if lst2[idx] not in lst1:
                del lst2[idx]
                if lst2 == lst1:
                    result = True
                    break
                else:
                    result = False
                    break
    #제거의 경우
    #하나를 제거했을 때 같은지 확인
    elif len(s1) > len(s2):
        if s2 in s1:
            result = True
        else:
            result = False

    #변환의 경우
    #s1,s2의 공통점이 len(s1) - 1 인지 확인
    else:
        set1 = set(lst1)
        set2 = set(lst2)
        if  len(set1.intersection(set2)) == len(s1) - 1:
            result = True
        else:
            result = False

    return result

나름 고민했긴 했는데 이미 다른 분들이 고안하신 방법이네요 ㅎㅎㅎ;;

def OneEditApart(s1, s2):
    #변환시 같을지 확인
    if(len(s1) == len(s2)):
        for i in range(len(s1)):
            if s1[:i] + s1[i+1:] == s2[:i] + s2[i+1:]:
                return True
    #추가 또는 제거시 같을지 확인
    else:
        for i in range(len(s1)):
            if s1[:i] + s1[i+1:] == s2:
                return True
        for i in range(len(s2)):
            if s2[:i] + s2[i+1:] == s1:
                return True
    return False



print(OneEditApart("cat", "dog"))
print(OneEditApart("cat", "cats"))
print(OneEditApart("cat", "cut"))
print(OneEditApart("cat", "cast"))
print(OneEditApart("cat", "at"))
print(OneEditApart("cat", "acts"))

def OneEditApart(s1,s2):
    if abs(len(s1)-len(s2)) > 1: return False
    ix,flag = 0,0
    for i in s1:
        if s2[ix:].find(i) == -1:
            if flag == -1: return False
            flag += 1
        else:
            tmp = s2[ix:].find(i)+1
            if tmp-1 > 1: return False
            ix += tmp
            flag -= (tmp-1)
        if flag > 1: return False
    return True

a = ['cat']*6
b = ['dog','cats','cut','cast','at','acts']

print(tuple(map(OneEditApart,a,b)))

파이썬3

def OneEditApart(s1, s2):
    if s1 == s2:
        return False

    if len(s1) != len(s2):
        if len(s1) < len(s2):
            short_list, long_list = list(s1), list(s2)
        elif len(s1) > len(s2):
            short_list, long_list = list(s2), list(s1)

        for i in range(len(long_list)):
            temp = long_list[:]
            temp.pop(i)
            if temp == short_list:
                return True

    if len(s1) == len(s2):
        for i in range(len(s1)):
            temp1 = list(s1)[:]
            temp1.pop(i)
            for j in range(len(s2)):
                temp2 = list(s2)[:]
                temp2.pop(j)
                if temp1 == temp2:
                    return True
    return False

print(OneEditApart("cat", "dog"))
print(OneEditApart("cat", "cats"))
print(OneEditApart("cat", "cut") )
print(OneEditApart("cat", "cast"))
print(OneEditApart("cat", "at"))
print(OneEditApart("cat", "acts"))

s1과 s2는 다르다고 전제했습니다.

def one_edit_apart(string_s1, string_s2):

    longer, shorter = (lambda x, y: (x, y) if len(x) >= len(y) else (y, x))(string_s1, string_s2)

    if len(longer) - len(shorter) >= 2:
        return False
    else:
        difference = set(longer).difference(set(shorter))
        if len(difference) == 0:
            copy = list(longer)
            for letter in set(copy):
                copy.remove(letter)
            difference = copy[0]
        else:
            difference = list(difference)[0]

        replacement = [shorter.replace(shorter[i], difference) for i in range(1, len(shorter))]
        extention = [shorter[:i] + difference + shorter[i:] for i in range(0, len(shorter) + 1)]

        if longer in replacement + extention:
            return True
        else:
            return False

def Removal(a, b):
    for i in range(len(a)):
        x = a[:i]+a[i+1:]
        if b==x: return True
    return False

def Replace(a, b):
    for i in range(len(a)):
        x1 = a[:i]+a[i+1:]
        x2 = b[:i]+b[i+1:]
        if x1==x2: return True
    return False

def OneEditApart(a, b):
    if len(a) > len(b):   return Removal(a, b)
    elif len(a) < len(b): return Removal(b, a)
    else:                 return Replace(a, b)

def one_edit_apart(s1,s2) :
    compare_big = ""
    compare_small = ""
    compare_str = ""
    len_s1 = len(s1)
    len_s2 = len(s2)
    if len_s1== len_s2 :
        #길이가 같으면 변환된 케이스
        compare_big = s1
        for i in range (0, len(compare_big)) :
            if s1[i] !=s2[i] :
                #동일한 문자를 넣어준다.
                compare_str = s2.replace(s2[i],s1[i])
                break
        if compare_big == compare_str :
            return "true"
        else :
            return "false"
    else :
        #길이가 같지 않으면 삽입 or 제거된 케이스
        if len_s1 > len_s2 :
            compare_big = s1
            compare_small = s2
        else :
            compare_big = s2
            compare_small = s1
        #문자를 삽입한다.
        for i in range(0, len(compare_small)) :
            if s1[i]!= s2[i] :
                compare_str = compare_small[:i]+compare_big[i]+compare_small[i:]
                break
        #중간에 삽입된 문자가 없을 경우, 마지막에 삽입해준다.
        if compare_str == "" :
            compare_str = compare_small+compare_big[len(compare_big)-1]
            if compare_big == compare_str :
                return "true"
        if compare_big == compare_str :
            return "true"
        return "false"

public class KimSanghyeop {

    public static void main(String args[])
    {
        System.out.println(OneEditApart("cat","dog"));
        System.out.println(OneEditApart("cat","cats")); 
        System.out.println(OneEditApart("cat","cut"));
        System.out.println(OneEditApart("cat","cast"));
        System.out.println(OneEditApart("cat","at"));
        System.out.println(OneEditApart("cat","acts"));
        System.out.println(OneEditApart("cat","ct"));
    }

    static boolean OneEditApart(String s1, String s2)
    {

        char[] arr1 = s1.toCharArray();
        char[] arr2 = s2.toCharArray();

        int cnt=0;
        int len_num = Math.abs(arr1.length-arr2.length);
        if( len_num == 0)
        {

            // 변환 체크
            for(int f1=0;f1<arr1.length;f1++)
            {
                if(arr1[f1] != arr2[f1])
                {
                    cnt+=1;
                }
            }
            return cnt <=1 ? true : false;
        }
        else if (len_num==1)
        {
            StringBuffer sb1 = new StringBuffer(s1);
            StringBuffer sb2=  new StringBuffer(s2);

            // 상입 및 제거 체크 (길이가 큰놈에서 다른거 제거시 일치하면 true)
            for(int f1=0;f1<arr1.length;f1++)
            {
                if(arr1[f1] != arr2[f1])
                {

                    if(arr1.length>arr2.length)
                    {
                        sb1.deleteCharAt(f1);
                    }
                    else
                    {
                        sb2.deleteCharAt(f1);
                    }

                    return sb1.toString().equals(sb2.toString()) ? true : false;
                }
            }

            return true;
        }
        else
        {
            return false;
        }
    }
}

def OneEditApart(s1,s2):

    s1,s2 = [s1,s2] if len(s1) > len(s2) else [s2,s1]

    torf = False

    for x in range(len(s1)):

        if (s1[:x]+('' if x+1 == len(s1) else s1[x+1:]) ==
            s2[:x]+('' if x+1 == len(s2) else s2[x+1:]) or
            s1[:x]+('' if x+1 == len(s1) else s1[x+1:]) == s2):
            torf = True

    print('True' if torf == True else 'False')

C#

public static bool OneEditApart(string strA, string strB)
{
    string strLong = strA.Length >= strB.Length ? strA : strB; //긴 문자열
    string strShort = strA.Length >= strB.Length ? strB : strA; // 짧은 문자열

    if (strLong.Length == strShort.Length) // 길이가 같을 경우
    {
        // 일치하는 문자의 개수가 문자열 길이 - 1 => OneEditApart true
        var matchCount = Enumerable.Range(0, strLong.Length)
            .Where(idx => strLong[idx] == strShort[idx]).Count();
        return matchCount == strLong.Length - 1;
    }
    else // 길이가 다를 경우
    {
        // 긴 문자열에서 각 문자를 하나씩 뺸 컬렉션에 짧은 문자열 포함 => OneEditApart true
        var oneEdited = Enumerable.Range(0, strLong.Length)
            .Select(idx => strLong.Remove(idx, 1));
        return oneEdited.Any(e => e == strShort);
    }
}

def Remove_or_Insert(s1, s2):
    s1 = list(s1)
    s2 = list(s2)
    t = 0

    for i in range(len(s2)):
        if s1[i] != s2[i]:
            t = s1.pop(i)
            break
    if t == 0:
        s1.pop()

    if s1 == s2:
        return 'true'
    else:
        return 'false'


def Change(s1, s2):
    s1 = list(s1)
    s2 = list(s2)
    count = 0

    for i in range(len(s1)):
        if s1[i] != s2[i]:
            count += 1

    if count < 2:
        return 'true'
    else:
        return 'false'

def OneEditApart(s1,s2):
    if len(s1) > len(s2) and abs(len(s1) - len(s2)) == 1:
        print(Remove_or_Insert(s1,s2))
    elif len(s2) > len(s1) and abs(len(s1) - len(s2)) == 1:
        print(Remove_or_Insert(s2,s1))
    elif len(s1) == len(s2):
        print(Change(s1,s2))
    else:
        print('false')

OneEditApart('cat', 'acts')

def OneEditApart(s1, s2):
    s1, s2 = list(s1), list(s2)
    if len(s1) == len(s2):        
        for i in range(len(s1)):
            temp1, temp2 = s1[:], s2[:]
            del(temp1[i])
            del(temp2[i])
            if temp1 == temp2:
                return True

    if len(s1) > len(s2): s1, s2 = s2, s1
    for i in range(len(s2)):
        temp2 = s2[:]
        del(temp2[i])
        if s1 == temp2:
            return True
    return False


print(OneEditApart("cat", "dog"))
print(OneEditApart("cat", "cats"))
print(OneEditApart("cat", "cut"))
print(OneEditApart("cat", "cast"))
print(OneEditApart("cat", "at"))
print(OneEditApart("cat", "acts"))

def OneEditApart(s1,s2):
    count=0
    if abs(len(s1)-len(s2))>=2:
        return "false"

    elif abs(len(s1)-len(s2))==1:
        for i in range(min(len(s1),len(s2))):
            if  s1[i]!=s2[i]:
                return "false"

        return "true"

    else:
        for i in range(len(s1)):
            if s1[i]!=s2[i]:
                count+=1

        if count!=1:
            return "false"
        else:
            return "true"

def string_rm(string):
    str_list = list()
    tmp = string
    for x in range(len(string)):
        tmp= string[:x]+string[x+1:]
        str_list.append(tmp)
    return str_list

def OneEditApart(s1,s2):
    if abs(len(s1)-len(s2))>=2:
        return False
    elif abs(len(s1)-len(s2))==1:
        if len(s1)>len(s2):
            if s2 in string_rm(s1):
                return True
            else:
                return False
        elif len(s1)<len(s2):
            if s1 in string_rm(s2):
                return True
            else:
                return False
    elif len(s1)-len(s2) ==0:
        if s1 == s2:
            return True
        elif s1!= s2:
            for x in range(len(s1)):
                if string_rm(s1)[x] in string_rm(s2):
                    return True
            else:
                return False


print (OneEditApart("cat", "dog"))
print (OneEditApart("cat", "cats"))
print (OneEditApart("cat", "cut"))
print (OneEditApart("cat", "cast"))
print (OneEditApart("cat", "at"))
print (OneEditApart("cat", "acts"))

def OneEditApart(s1, s2):
    # True
    if s1 == s2: return True
    else:
        if abs(len(s1)-len(s2)) > 1: return False # cattt ...
        elif abs(len(s1)-len(s2)) == 1: #insert, delete
            ist = set(s2) - set(s1)
            dlt = set(s1) - set(s2)
            if ist == set() : # insert
                for s in s1:
                    if s2.count(s) == 2: return True
                if s2 == s1.replace(list(dlt)[0], ''): return True  # delete
            elif s1 == s2.replace(list(ist)[0], ''): return True # insert
            elif s2 == s1.replace(list(dlt)[0], ''): return True # delete
            else: return False # dogs, dsof...
        elif abs(len(s1)-len(s2)) == 0: # convert
            cnt =0
            for i in range(len(s1)):
                if s1[i] != s2[i]: cnt += 1
            if cnt <= 1: return True
            else: return False
        else: return False

만드니까 모양이..

def OneEditApart(s1, s2):
    if abs(len(s1)-len(s2)) > 1: return False
    if len(s1) < len(s2): # insert
        if set(s1) == set(s2):
            cnt = 0
            for s in s1:
                if s2.count(s) == 2: cnt += 1
            if cnt == 2: return True
            else: return False
        elif s1 == s2.replace(list(set(s2) - set(s1))[0], ''): return True
        else: return False
    if len(s1) > len(s2): # delete
        if s2 == s1.replace(list(set(s1) - set(s2))[0], ''): return True
        else: return False
    if len(s1) == len(s2): # convert
        cnt = 0
        for a, b in zip(s1, s2):
            if a != b: cnt += 1
        if cnt <= 1: return True
        else: return False

정리해봐도 줄어들진 않네요.

def OneEditApart(txt1,txt2):
    count1=0
    count2=0
    if len(txt1) < len(txt2):
        txt1=txt1 + " "
        txt1_1 = " "+txt1
        for i in range(len(txt1)):
            if txt1[i] == txt2[i] :                
                count1 +=1
            if txt1_1[i] == txt2[i] :                
                count2 +=1
        if max(count1,count2) >= 2:            
            print("true")
        else :
            print("false")

    elif len(txt1) > len(txt2):
        txt2=txt2 + " "
        txt2_1 = " "+txt2
        for i in range(len(txt1)):
            if txt1[i] == txt2[i]:
                count1 +=1                
            if txt1[i] == txt2_1[i] :
                count2 +=1                        
        if max(count1,count2) >= 2:
            print("true")
        else :
            print("false")

    else :
        for i in range(len(txt1)):
            if txt1[i] == txt2[i] :                
                count1 +=1                
        if count1 >= 2:
            print("true")
        else :
            print("false")



OneEditApart("cat", "dog") 
OneEditApart("cat", "cats")
OneEditApart("cat", "cut") 
OneEditApart("cat", "cast") 
OneEditApart("cat", "at")
OneEditApart("cat", "acts")

python3

def OneEditApart(s1, s2):
  if len(s1) == len(s2):
    print(s1 == s2)
    return 'true'

  else:
    if len(s1) > len(s2):
      large = s1
      small = s2
    else:
      large = s2
      small = s1

    for i in range(len(large)):
      ss = []
      for k, s in enumerate(large):
        if not(i == k):
          ss.append(s)
      a =''.join(ss)
      if a == small:
        print('true', a, small)
        return 'true'
  print('false')
  return 'false'


OneEditApart("cat", "dog")
OneEditApart("cat", "cats")
OneEditApart("cat", "cut")
OneEditApart("cat", "cast")
OneEditApart("cat", "at")
OneEditApart("cat", "acts") 

출력:
False
true cat cat
False
true cat cat
true at at
false

public class 비슷한단어찾아내기 {

    public static void main(String[] args) {
        OneEditApart("cat", "dog");
        OneEditApart("cat", "cats");
        OneEditApart("cat", "cut");
        OneEditApart("cat", "cast");
        OneEditApart("cat", "at");
        OneEditApart("cat", "acts");
    }

    public static void OneEditApart(String s1, String s2) {

        String[] arrS1 = s1.split("");
        String[] arrS2 = s2.split("");
        if(s1.length()==s2.length()) {
            int count = 0;
            for(int i=0; i<s1.length(); i++) {
                if(arrS1[i].equals(arrS2[i])) {
                    count++;
                }
            }
            if(count>1) {
                System.out.println(true);
            }
            else {
                System.out.println(false);
            }
        }
        if(s1.length()<s2.length()) {
            int count = 0;
            if(arrS1[0].equals(arrS2[0])) {
            for(int i=0; i<s1.length(); i++) {
                for(int j=i; j<s2.length(); j++) {
                    if(arrS1[i].equals(arrS2[j])) {
                        count++;
                        break;
                    }
                }
            }
            if(count>1) {
            System.out.println(true);
        }
            else {
                System.out.println(false);
            }
        }
            else {
                for(int i=0; i<s1.length(); i++) {
                    for(int j=1; j<s2.length(); j++) {
                        if(arrS1[i].equals(arrS2[j])) {
                            count++;
                            break;
                        }
                    }
                }
                if(count>2) {
                    System.out.println(true);
                }
                else {
                    System.out.println(false);
                }
            }
        }
        if(s1.length()>s2.length()) {
            int count =0;
            for(int i=0; i<s2.length(); i++) {
                for(int j=i; j<s1.length(); j++) {
                    if(arrS2[i].equals(arrS1[j])){
                        count++;
                        break;
                    }
                }
            }
            if(count>1) {
                System.out.println(true);
            }
            else {
                System.out.println(false);
            }
        }
    }
}

def str_comp(str1, str2):           # 원본 문자 str1/ 비교대상 문자 str2, var_s2
    cnt = -1                        # 원본 문자 순서로 비교 대상 문자의 첫번째 인덱스와 확인한 후
    var_s2 = str2.copy()            # 비교 대상 문자의 비교했던 첫번째 문자 제거, 같으면 인덱스 증가
    for i in str1:                  # 다르면 비교대상 문자의 인덱스를 추출 후 loop를 빠져나옴
        if i == var_s2[0]:          # OneEditApart 함수에 문자의 차이가 났던 인덱스 번호를 리턴함
            cnt += 1
            del var_s2[0]
        elif i != var_s2[0]:
            idx = cnt+1
            break
    if (len(str1)-1) == cnt:
        idx = len(str2) - 1
    return idx

def OneEditApart(str1, str2):       # 비교 문자간 길이를 확인하여 삽입, 변환, 제거로 분류하여 함수 호출
    idx = str_comp(str1, str2)
    if len(str1) < len(str2):       # 문자 삽입
        del str2[idx]
    elif len(str1) == len(str2):    # 문자 변환
        del str1[idx]
        del str2[idx]
    else:                           # 문자 제거
        del str1[idx]

    return 'True' if str1 == str2 else 'False'

def main():
    words = [('cat', 'dog'),
             ('cat', 'cats'),
             ('cat', 'cut'),
             ('cat', 'cast'),
             ('cat', 'at'),
             ('cat', 'acts')]

    for str1, str2 in words:
        print('OneEditApart({}, {}) = {}'.format(str1, str2, OneEditApart(list(str1), list(str2))))

if __name__ == '__main__':
    main()

def check_one_edit_apart(s1, s2):
    length_diff = abs(len(s1) - len(s2))
    if length_diff == 0:
        return [s1[i] != s2[i] for i in range(len(s1))].count(True) <= 1
    elif length_diff == 1: 
        s1, s2 = (s1, s2) if len(s1) > len(s2) else (s2, s1)
        longer_length = len(s1)
        s1_removed_list = [s1[0:i] + s1[i + 1:longer_length + 1] for i in range(longer_length)]
        return s2 in s1_removed_list
    else: 
        return False

def OneEditApart(s1,s2):
    j=0
    if abs(len(s1)-len(s2))>1:
        return "False"
    for i in range(min(len(s1),len(s2))):
        if s1[i]!=s2[i] and s1[::-1][i]!=s2[::-1][i]:
            j+=1
    if j<=1:
        return "True"
    else:
        return "False"

결과

print(OneEditApart("cat", "dog")) #False
print(OneEditApart("cat", "cats")) #True
print(OneEditApart("cat", "cut")) #True
print(OneEditApart("cat", "cast")) #True
print(OneEditApart("cat", "at")) #True
print(OneEditApart("cat", "acts")) #False
print(OneEditApart("cat", "cataa")) #False

def OneEditApart(s1, s2):
    print(s1,',',s2,'---->',end=' ')

    ss1,ss2=[],[]
    for i in range (len(s1)):
        ss1.append(s1[i])
    for i in range (len(s2)):
        ss2.append(s2[i])

    if len(s2)-len(s1)>1 or len(s1)-len(s2)>1:  #s2가 s1에 비해 2이상 길거나, 2이상 짧으면 False
        print (False)

    elif len(s1)-len(s2)==1: #s2가 s1보다 1만큼 짧을경우 (1문자가 삭제된 경우)
        i=0
        while (len(ss1)):
            if ss1[i] not in ss2: 
                del ss1[i]
                break
            else:
                i+=1
        if ss1==ss2:
            print (True)
        else:
            print (False)

    elif len(s2)-len(s1)==1: #s1이 s2보다 1만큼 짧을경우 (1문자가 추가된 경우)
        ss2_condition='No New Character'
        for i in range (len(s2)):
            if ss2[i] not in ss1:
                ss2_condition='New Character'
                new_char=ss2[i]

        if ss2_condition=='New Character':  #s1에 포함되지 않은 문자가 s2에 추가된 경우
            ss2.remove(new_char)       
            if ss1==ss2:
                print (True)
            else:
                print (False)
        else:                               #s1에 포함된 문자가 s2에 추가된 경우
            for i in range (len(ss1)):
                if ss1.count(ss1[i]) != ss2.count(ss1[i]):  #중복된 문자 검출
                    duplicated_char=ss1[i]  
                    duplicated_char_position=[]
                    for j in range (len(ss2)):      #ss2에서 중복된 문자의 위치 검출
                        if duplicated_char==ss2[j]:
                            duplicated_char_position.append(j)

            for i in range (0,2):  
                temp=list(ss2)
                del temp[duplicated_char_position[i]]

                if ss1==temp:
                    result=True

            if result==True:
                print (True)
            else:
                print (False)

    elif len(s2)==len(s1): #s1과 s2의 길이가 같은 경우,
        if s1==s2:
            print (True)    
        else:               #길이는 같으나 내용이 서로 다를 경우,
            i=0
            while (i<len(ss1)):
                if ss1[i]!=ss2[i]:
                    ss2[i]=ss1[i]
                    break
                i+=1
            if ss1==ss2:
                print (True)
            else:
                print (False)

#2글자 이상 차이나는 경우,
OneEditApart("cat", "actsss")
OneEditApart("cat", "a")

#1글자 적은 경우,
OneEditApart("cat", "at")
OneEditApart("cat", "ta")

#1글자 많은 경우,
OneEditApart("cat", "cats")
OneEditApart("cat", "cast") 
OneEditApart("cat", "tcat")
OneEditApart("cat", "caat") 
OneEditApart("cat", "acts")

#글자가 같은 경우,
OneEditApart("cat", "dog") 
OneEditApart("cat", "cut")
OneEditApart("cat", "cat")

def OneEditApart(word,words):

  if word==words:

    return True

  wordA=[]

  wordB=[]

  for i in word:

    wordA.append(i)

  for j in words:

    wordB.append(j)

  if len(wordA)==len(wordB):

    difference=0

    for i in range(len(wordA)):

      if wordA[i]!=wordB[i]:

        difference+=1

    if difference>1:

      return False

    else:

      return True

  elif len(wordA)>len(wordB):

    k=0

    while k<len(wordB):

      if wordA[k]!=wordB[k]:

        del wordA[k]

        break

      k+=1

    if k==len(wordB):

      del wordA[k]

    if wordA==wordB:

      return True

    else:

      return False

  elif len(wordB)>len(wordA):

    k=0

    while k<len(wordA):

      if wordB[k]!=wordA[k]:

        del wordB[k]

        break

      k+=1

    if k==len(wordA):

      del wordB[k]

    print(wordA)

    print(wordB)

    if wordA==wordB:

      return True

    else:

      return False

print(OneEditApart('cat','cut'))

print(OneEditApart('cat','cats'))

def check1(s1, s2):
    for i in range(len(s1)):
        temp = s1[:i] + s1[i+1:]
        if s2 == temp: return True
    return False

def check2(s1, s2):
    for i in range(len(s1)):
        temp1 = s1[:i] + s1[i+1:]
        temp2 = s2[:i] + s2[i+1:]
        if temp1 == temp2: return True
    return False

def OneEditApart(s1, s2):
    if len(s1) > len(s2):
        return check1(s1, s2)
    elif len(s1) < len(s2):
        return check1(s2, s1)
    else:
        return check2(s1, s2)

print(OneEditApart("cat", "cats"))
print(OneEditApart("cat", "cut"))
print(OneEditApart("cat", "cast"))
print(OneEditApart("cat", "at"))
print(OneEditApart("cat", "acts"))

letter = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']

def OneEditApart(w1, w2):
    result = False

    # 삽입
    a = list(w1)
    for i in range(len(a)+1):
        for j in letter:
            a = list(w1)
            a.insert(i, j)
            if a == list(w2):
                result = True
                return result
    # 제거
    a = list(w1)
    for i in range(len(a)):
        a = list(w1)
        del a[i]
        if a == list(w2):
            result = True
            return result
    # 변환
    b = w1
    for i in b:
        for j in letter:
            b = w1
            if b.replace(i, j) == w2:
                result = True
                return result

    return result

print(OneEditApart('cat', 'dog'))
print(OneEditApart('cat', 'cats'))
print(OneEditApart('cat', 'cut'))
print(OneEditApart('cat', 'cast'))
print(OneEditApart('cat', 'at'))
print(OneEditApart('cat', 'acts'))

def OneEditApart(s1,s2):
    cnt=0
    if abs(len(s1)-len(s2))>1:
        return "False"
    for i in range(min(len(s1),len(s2))):
        if s1[i]!=s2[i] and s1[::-1][i]!=s2[::-1][i]:
            cnt+=1
    if cnt<=1:
        print("True")
    else:
        print("False")

OneEditApart("cat","ct")

def OneEditApart(s1, s2):
    length_s1 = len(s1)
    length_s2 = len(s2)
    length = max(length_s1, length_s2)

    # 두 문자열의 길이가 같은 경우
    if length_s1 == length_s2:
        for i in range(length):
            if s1[:i]+s1[i+1:] == s2[:i]+s2[i+1:]:
                return True

    # 두 문자열의 길이 다른 경우
    else:
        if length_s1 > length_s2:
            long_str = s1
            short_str = s2
        elif length_s1 < length_s2:
            long_str = s2
            short_str = s1        

        for i in range(length):
            test_str = long_str[:i] + long_str[i+1:]
            if short_str == test_str:
                return True

    return False



print(OneEditApart("cat", "dog"))
print(OneEditApart("cat", "cats"))
print(OneEditApart("cat", "cut"))
print(OneEditApart("cat", "cast"))
print(OneEditApart("cat", "at"))
print(OneEditApart("cat", "acts"))

문자열 슬라이싱을 이용하여 처리하는 방법을 새롭게 배웠네요

def makeAns(str1, str2):
    diff = 0
    list1 = [str1[i] for i in range(0, len(str1))]
    list2 = [str2[i] for i in range(0, len(str2))]
    if len(list2) < len(list1):
        list2.insert(0, " ")
    for i in range(0, len(list1)):
        if list1[i] != list2[i]:
            diff += 1

    if diff < 2:
        print(True)
    else:
        print(False)


makeAns("cat", "dog")
makeAns("cat", "cats")
makeAns("cat", "cut")
makeAns("cat", "cast")
makeAns("cat", "at")
makeAns("cat", "acts")

결과
False
True
True
True
True
False

def one(x,y) :
    if x==y : print('true')

    elif len(x)==len(y):
        count = []
        for i in x :
            if i in y: pass
            else : count.append(i)
        if len(count)==1 : print(f'{y} true1')
        else : print(f'{y} false1')

    elif len(x)==len(y)-1:
        n=1
        while n<len(y):
            if x==y[0:n]+y[n+1:len(y)]:
                print(f'{y} true2')
                break
            elif y==x[n:n+1]+x[n+1:len(x)]:
                print(f'{y} true3')
                break
            else : n+=1     
        else : print(f'{y} false2')

    elif len(x)-1==len(y):
        n=1
        while n<len(x):
            if y==x[0:n]+x[n+1:len(x)]:
                print(f'{y} true3')
                break
            elif y==x[n:n+1]+x[n+1:len(x)]:
                print(f'{y} true3')
                break
            else : n+=1     
        else : print(f'{y} false3')

    else :print('false4')

def OneEditApart(a,b):
    count = 0
    if len(a) <= len(b):
     A = [i for i in a]
     B = [j for j in b]
     for i,j in zip(A,B):
         if i == j:count += 1
     if count >= 2: print('true')
     else: print('false')
    elif b in a: print('true')
    else: print('false')
    return

#codingdojing_similar_word_re

# delete/insert 두문자중에 큰거를 기준으로 1글자씩 뺐을때 같은글자인지 확인.
# 두 글자수의 차이가 1개여야함.
# 만약에 글자수가 같다, 그러면 두 글자를 같은 위치를 slicing 해서 같은지 비교한다.

import sys

def OneEditApart(s1, s2):

    if not(isinstance(s1, str) & isinstance(s2, str)):
        print("not string type")
        sys.exit()

    if len(s1) == len(s2):
        result = check_replace(s1, s2)         
    elif len(s1) - len(s2) == 1: #s1이 더 크면
        result = check_removal(s1, s2)
    elif len(s2) - len (s1) == 1: #s2가 더 크면
        result = check_removal(s2, s1)
    else:
        result = False

    print(result)

def check_replace(s1, s2):       
    for i in range(len(s1)):
        if s1[:i]+s1[i+1:] == s2[:i]+s2[i+1:]: #i번째 index 제외
            return True
    return False      

def check_removal(s1, s2):  #s1 > s2
    for i in range(len(s1)):
        if s2 == s1[:i]+s1[i+1:]: #i번째 index제외하고 비교
            return True
    return False    

OneEditApart("cat", "dog")
OneEditApart("cat", "cats")
OneEditApart("cat", "cut")
OneEditApart("cat", "cast")
OneEditApart("cat", "at")
OneEditApart("cat", "acts")

"""
1. 문자수 같음
  1-1 문자 1개 다름 True
  1-2 문자 1개이상 다름 False

2. 문자수 1개 차이
  2-1 중간에 문자 하나 뻇을떄 같으면 True
  2-2 아니면 False

3. 문자수 2개이상 차이 False

"""
def OneEditApart(a,b) :
    al =len(a)
    bl =len(b)
    a_arr =list(a)
    b_arr =list(b)
    n=0
    if al == bl:               #1.
      for k in range(al):
        if a[k] != b[k]:
          n+=1
      if n>1:
        return False           #1-2
      else :           
        return True            #1-1
    elif abs(al-bl) ==1:       #2.
      if al < bl :             #a,b 길이 비교
        for k in range(bl):
          c = b_arr.copy()
          c.pop(k)
          if c == a_arr :       #2-1 index 하나씩 제거해봤을때 다른 문자열과 동일해지는지 검증
            return True
            break
        return False
      if al > bl :            #a,b 길이 비교
        for k in range(al):
          c = a_arr.copy()
          c.pop(k)
          if c == b_arr :
            return True
            break
      return False
    else:                      #3.
      return False




a= OneEditApart("cattttt", "castttt")
b= OneEditApart("cat", "cats")
c= OneEditApart("cat", "cut")  
d= OneEditApart("cat", "cast")  
e= OneEditApart("cat", "at") 
f= OneEditApart("cat", "acts") 

print(a,b,c,d,e,f)

def OneEditApart(s1,s2) :
    false_count = 0
    s1,s2 = list(s1),list(s2)

    if len(s1) - len(s2) < 0 : s1,s2 = s2,s1

    if len(s1)-len(s2) == 1 :
        s3 = set(s1) - set(s2)
        s1.remove(list(s3)[0])
        false_count += 1

    if len(s1) == len(s2) :
        for i in range(0,len(s1)) :
            if s1[i] != s2[i]: false_count += 1

            if false_count == 2: return False
        return True
    return False

print(OneEditApart("cat","dog"))
print(OneEditApart("cat","cats"))
print(OneEditApart("cat","cut"))
print(OneEditApart("cat","cast"))
print(OneEditApart("cat","at"))
print(OneEditApart("cat","acts"))

// Rust

// 슬라이스 비교를 위해 Vec로 변환합니다

[allow(unused)]

fn one_char_difference(s1: &str, s2: &str) -> bool {

let mut v1: Vec<char> = s1.chars().collect();
let mut v2: Vec<char> = s2.chars().collect();
if s1.len() < s2.len() {
    removal_equivalence(v1, v2)
} else if s1.len() > s2.len() {
    removal_equivalence(v2, v1)
} else {
    replace_equivalence(v1, v2)
}

} fn replace_equivalence(v1: Vec, v2: Vec) -> bool {

for i in 0..v1.len() {
    if v1[..i] == v2[..i] && v1[i+1..] == v2[i+1..] {
        return true;
    }
}
false

} fn removal_equivalence(v1: Vec, v2: Vec) -> bool {

let l = v2.len();
for i in 0..l {
    if v2[..i] == v1[..i] && v2[i+1..] == v1[i..] {
        return true
    }
}
false

}

[test]

fn test() {

assert_eq!(one_char_difference("cat", "dog"), false);
assert_eq!(one_char_difference("cat", "cats"), true);
assert_eq!(one_char_difference("cat", "cut"), true);
assert_eq!(one_char_difference("cat", "cast"), true);
assert_eq!(one_char_difference("cat", "at"), true);
assert_eq!(one_char_difference("cat", "acts"), false);

}

def OneEditApart(s,t):
    insert = (t in [s[:x]+s[x+1:] for x in range(len(s))]) or (s in [t[:x]+t[x+1:] for x in range(len(t))])

    if len(s) == len(t):
        repl = [s[i] == t[i] for i in range(max(len(s),len(t)))].count(False) == 1
    else:
        repl = False

    return insert or repl

OneEditApart("cat", "acts")

밑에꺼는 부족하다싶은 조건들 그냥 더달아봤습니다. 어디서 걸리는지 보려고 print에 문구추가했습니다.

def samelen(s1,s2):
    for x in range(len(s1)):
        for y in range(len(s2)):
            s1_1 = list(s1)
            s2_1 = list(s2)
            del s1_1[x]
            del s2_1[y]
            if s1_1 == s2_1:
                return True

def diflen(s1,s2):
    s2_2 = list(s2)
    for z in range(len(s1)):
        s1_2 = list(s1)
        del s1_2[z]
        if s1_2 == s2_2:
            return True

def samein(s1,s2):
    count = 0
    for i in range(len(s1)):
        if s1[i] ==s2[i]:
            count += 1
    if count >= (len(s1) - 1):
        return True

def OEA(s1,s2):
    if len(set(s1+s2)) <= len(s1) or len(set(s1+s2)) <= len(s2):
        if len(s1) == len(s2):
            if samein(s1,s2) == True:
                return print('true samein')
            else:
                return print('false samein')
        elif len(s1) > len(s2):
            if diflen(s1,s2) == True:
                return print('true s1 > s2')
            else:
                return print('false s1 > s2')
        else:
            if diflen(s2,s1) == True:
                return print('true s1 < s2')
            else:
                return print('false s1 < s2')
    elif len(s1) == len(s2):
        if samelen(s1,s2) == True:
            return print('true same')
        else:
            return print('false same')
    else:
        return print('false last')

OEA('cat','dog')
OEA('cat','cats')
OEA('cat','cut')
OEA('cat','cast')
OEA('cat','at')
OEA('cat','acts')

OEA('cat','act')
OEA('cat','cat')
OEA('cat','ta')
OEA('cattt','cadttt')