[알고리즘 || 프로그래머스] 옹알이(2)

 

생각과 과정을 잘 정리하고 푸는 게 얼마나 중요한지 또 깨달았다.

 

어제는 풀려고 한 두시간 정도 시도 했는데 통과 못했다. 

연속된 문자는 말하지 못한다는 걸 늦게 인식했고, 어떻게 판별해야하나 뾰족한 수가 생각나지 않았다. 

(이미 좀 지침)

 

 

 

오늘은 어제 참석 못한 비난좌가 어제꺼 푼다고 하셔서 나도 다시 시도해보기로 했다. 

그리고 풀었다!! 야호!

 

 

 

 

function solution(babbling) {
    const words = ["aya", "ye", "woo", "ma"];
    const isSeries = (b, word) => {
        let s = b.replaceAll(word, "?");
        for (let i = 1; i < s.length; i++) {
            if (s[i] === "?") {
                if (s[i - 1] === "?") return true;
            }
        } return false;
    }

    words.map(w => {
        babbling = babbling.map(b => {
            if (w.length > 1) {
                if (!isSeries(b, w)) {
                    return b.split(w).join(" ");
                }
            }
            return b;
        })
    })

    return babbling.filter(v => v.trim() == "").length
}

0. 가장 짧은 단어의 길이가 2이기 때문에 length 가 2미만인 단어는 걸러낸다. (검사하지 않는다.)

1. 연속되는 단어가 들어있는 옹알이는 걸러낸다. => isSeries 가 false 여야함. 

1-1. isSeries 함수에서 maping 되고 있는 단어를 특수한 문자("?")로 대체한 후,

     그 문자가 연속해서 있는 경우 true 를 반환한다. 

2. 단어 길이가 최소 2이고, 연속된 문자가 없는 경우의 옹알이들만 split을 통해 없애준다.(소거)

3. 하지만 join()을 공백으로 처리하면 이전 단어로 소거된 옹알이가 단어와 일치하는 경우도 생길 수 있기 때문에

(ex) "myeyea") 

" " 띄어쓰기를 해서 붙지 않게 처리해줬다. 

 

이 과정을 거친 단어를 trim() 했을 때 "" 인 단어 즉, 모두 걸러진 단어의 길이만 세면 

주어진 단어로 말할 수 있는 옹알이의 수를 알 수 있다. 

 

ㅋㅋㅋㅋㅋ

1. isSeries 함수: 문자열 b에서 단어 word가 연속으로 등장하는지 확인하며, 연속 등장 시 true를 반환합니다.

2. map 함수: 'babbling' 배열의 각 원소에 대해 'words' 배열의 각 단어를 사용하여 연산을 수행합니다.

3. 단어 치환: 단어 w의 길이가 1보다 크고 'b'에서 w가 연속적으로 등장하지 않을 경우, 'b'에서 'w'를 공백으로 치환합니다.

4. 카운트: 수정된 'babbling' 배열에서 공백 문자열의 수를 카운트하고, 이를 반환합니다. 이는 머쓱이의 조카가 발음할 수 있는 단어의 수를 나타냅니다.

 

비난님이 깔끔하게 정리해주심ㅋㅋㅋ

 

 

이거슨 고수 비난좌의 코드.

보기만 해도 고수의 향기가 난다.

const solution = (babbling) => {
    const regex = /^(aya|ye|woo|ma)*$/;

    return babbling.reduce((count, babble) => {
        if (!babble.match(regex)) {
            return count;
        }

        let lastWord = '';
        let currentWord = '';
        for (let char of babble) {
            currentWord += char;

            if (['aya', 'ye', 'woo', 'ma'].includes(currentWord) && lastWord !== currentWord) {
                lastWord = currentWord;
                currentWord = '';
            }
        }

        return currentWord === '' ? count + 1 : count;
    }, 0);
}

 

char 를 이용해서 단어가 맞아지는지 확인하는 작업을 한다..

그리고 && 다음이 연속하는지 체크하는건가?

 

하고 있는데 친절하게 설명을ㅋㅋㅋㅋㅋㅋ

const regex = /^(aya|ye|woo|ma)*$/;

regex 정규 표현식은 "aya", "ye", "woo", "ma" 중 하나 또는 그 조합으로 이루어진 문자열과 일치하는지를 확인합니다. 여기서 '^'는 문자열의 시작을, '$'는 문자열의 끝을 나타냅니다. 

return babbling.reduce((count, babble) => {

reduce 함수는 'babbling' 배열의 각 원소에 대해 작업을 수행하고, 그 결과를 누적하여 반환합니다. 여기서는 각 원소가 머쓱이의 조카가 발음할 수 있는 단어인지를 확인하고, 그 결과를 카운트에 누적합니다.

 if (!babble.match(regex)) {
            return count;
        }

따라서 이 정규 표현식은 문자열 전체가 "aya", "ye", "woo", "ma" 중 하나 또는 그 조합으로 이루어졌는지를 확인합니다. 
만약 이 조건에 맞지 않으면, 그 원소는 머쓱이의 조카가 발음할 수 없는 단어이므로 카운트를 증가시키지 않습니다.

문자열을 순회하기 시작합니다. 각 문자를 currentWord에 추가합니다.
for (let char of babble) {
    currentWord += char;

currentWord가 'aya', 'ye', 'woo', 'ma' 중 하나에 포함되는지 확인합니다. 이것은 만약 currentWord가 이들 중 하나와 일치하면, 우리는 완전한 단어를 찾았음을 의미합니다. 동시에, 이 단어는 이전에 찾은 단어(lastWord)와 같지 않아야 합니다. 이는 조카가 연속된 같은 단어를 발음하지 않는다는 규칙을 만족시킵니다.

if (['aya', 'ye', 'woo', 'ma'].includes(currentWord) && lastWord !== currentWord) {

만약 currentWord가 찾고 있는 단어 목록에 있고 이전 단어와 다르다면, lastWord에 현재 단어를 저장하고 currentWord를 초기화합니다. 이를 통해 새로운 단어를 찾기 시작합니다.

    lastWord = currentWord;
    currentWord = '';
}

모든 문자를 순회한 후에, currentWord가 빈 문자열인지 확인합니다. 만약 currentWord가 빈 문자열이라면, babble이 규칙에 따라 올바르게 발음할 수 있는 단어들로만 구성되어 있다는 뜻이므로 카운트를 증가시킵니다. 반대로 currentWord가 빈 문자열이 아니라면, 마지막 단어가 완성되지 않은 것이므로 카운트를 증가시키지 않습니다.
return currentWord === '' ? count + 1 : count;

이와 같이 작동하는 방식으로 'babbling' 배열의 각 원소가 머쓱이의 조카가 발음할 수 있는 단어인지 판단하고, 가능한 단어의 수를 반환합니다.

ㅋㅋㅋㅋㅋㅋ

가끔 아니 종종 비난봇이라고 부르는데 오늘은 특히 더 봇같으심ㅋㅋㅋㅋㅋㅋㅋ

 

 

 

 

헤헤 풀면 또 재밌고 못풀면 재미없고 어렵고 그르넹

 

 

 

 

 

 

 

+ 충격의 풀이

function solution(babbling) {
  const regexp1 = /(aya|ye|woo|ma)\1+/;
  const regexp2 = /^(aya|ye|woo|ma)+$/;

  return babbling.reduce((ans, word) => (
    !regexp1.test(word) && regexp2.test(word) ? ++ans : ans
  ), 0);
}