개발자 김수진

인공지능(AI)은 현대 소프트웨어 개발에서 핵심적인 역할을 수행하고 있습니다. 특히, 프론트엔드 개발자들에게는 AI를 활용하여 사용자 경험을 향상시키고 개발 효율성을 높이는 다양한 방법이 존재합니다. 이번 글에서는 프론트엔드 개발자가 AI를 효과적으로 활용할 수 있는 기술적 접근법을 살펴보겠습니다.

1) AI 기반의 코드 자동 완성 및 최적화

AI는 코드 작성 과정에서 자동 완성 기능을 제공하여 개발자의 생산성을 높입니다. 또한, AI는 코드의 복잡성을 분석하고 최적화 방안을 제시하여 성능 향상에 기여합니다. 저도 실제로 개발하면서 많이 사용하고 있는데 작업 시간이 정말 단축된 것을 느낄 수 있고 제가 생각하지 못한 부분에 대해서도 제안해주니 제 개발 실력에도 많은 도움이 됩니다.

아래는 대표적인 도구들입니다.

• GitHub Copilot: OpenAI Codex를 기반으로 하여 GitHub과 Microsoft가 공동 개발한 AI 코드 자동 완성 도구입니다. Visual Studio Code와 같은 편집기에서 확장 프로그램으로 사용되며, JavaScript, Python, TypeScript 등 다양한 언어를 지원합니다.
  GitHub Copilot 바로가기
• Cursor AI: Visual Studio Code 사용자에게 최적화된 도구로, 코드를 작성하는 동시에 성능을 실시간으로 최적화할 수 있습니다. AI 기반 실시간 코드 최적화와 자연어 명령어 지원 기능을 제공합니다.
  Cursor AI 바로가기
• Tabnine AI: 딥러닝 알고리즘을 사용하여 지능형 코드 완성을 제공하는 도구로, 다양한 프로그래밍 언어와 IDE를 지원합니다. 개발자의 코딩 스타일에 맞게 적응하여 개인화된 코드 제안을 제공합니다.
  Tabnine AI 바로가기
• Codeium: 70개 이상의 프로그래밍 언어를 지원하며, 인기 있는 IDE에 통합되어 개발자가 더 빠르고 효율적으로 코드를 작성하는 데 도움을 줍니다. 무료로 제공되면서도 고급 기능을 제공합니다.
  Codeium 바로가기

2) AI를 활용한 이미지 및 비디오 처리 자동화

인공지능(AI)은 이미지 및 비디오 처리의 자동화를 통해 다양한 산업에서 혁신을 주도하고 있습니다. 특히, 디자인 리소스 플랫폼인 Freepik은 AI 기술을 적극 활용하여 사용자들에게 향상된 서비스를 제공하고 있습니다. 아래에서는 Freepik의 AI 활용 사례를 살펴보겠습니다.

Freepik의 AI 활용 사례

1. AI 이미지 생성기
   Freepik은 텍스트 프롬프트를 입력하면 실시간으로 이미지를 생성하는 AI 이미지 생성기를 제공합니다. 이를 통해 사용자는 원하는 이미지를 빠르게 얻을 수 있습니다.
2. AI 비디오 생성기
   Freepik의 AI 비디오 생성기는 텍스트나 이미지를 입력하면 몇 단계만으로 동영상을 제작할 수 있는 도구입니다. 다양한 모드를 선택하여 필요에 맞는 동영상을 생성할 수 있습니다.

이러한 AI 기반 기능들은 디자인 작업의 효율성을 높이고, 다양한 아이디어를 실현하는 데 큰 도움이 됩니다. 저도 실제로 이러한 AI 기술을 활용한 서비스를 개발 중인데, 사용자에게 더욱더 다양한 기능들을 제공할 수 있게 되었습니다.

AI로 한층 더 효율적인 프론트엔드 개발

[풀이]

우선순위를 기반으로 베스트 앨범에 들어갈 노래를 골라주면 된다.

1. 장르별 총 재생 수 기준 정렬

2. 각 장르별로 상위 2개의 노래 선택

장르별 총 재생 수를 저장하기 위해 totalPlays 라는 map을 선언했다. 

해당 map의  key는 장르, value는 총 재생횟수가 된다.

totalPlays에 값을 넣어줄 때는 getOrDefault 함수를 사용해

현재 genre에 해당하는 값이 존재하면 그 값을 가져오고, 

존재하지 않는다면 defaultValue인 0을 가져와 play 횟수를 더해준 값을 put 하도록 하였다.

또한 각 장르별 play를 관리하기 위해 genreInfo 라는 map을 선언했다.

마찬가지로 해당 map의 key는 genre 값이 되고, value로는 또 하나의 map이 된다.

value로 존재하는 map의 key는 고유 번호인 index 값, value는 해당 노래의 재생 횟수인 play를 저장한다.

이를 통해 genreInfo에서는 각 장르별 재생된 노래의 정보를 관리하고 있다.

genreInfo에 값을 넣어줄 때는 value가 HashMap이기 때문에 

key에 해당하는 값이 존재하는지 확인 후 존재하지 않는다면 새로운 map을 할당하고 put을 수행한다.

장르별 총 재생 횟수를 기준으로 노래를 선발하기 위해

장르별 총 재생횟수 값이 존재하는 totalPlays를 정렬해줘야 한다.

이 때 List와 같은 컬렉션(Collection) 타입 데이터를 정렬하는데 사용되는 Collections.sort를 사용했다.

List<String> keySet = new ArrayList(totalPlays.keySet());
Collections.sort(keySet, (o1 , o2) -> totalPlays.get(o2) - totalPlays.get(o1));

totalPlays.keySet()를 통해 map의 모든 key 값을 가져와 ArrayList 형태로 변환해준다.

• Set은 정렬이 불가능하지만, List는 정렬이 가능하기 때문

Collections.sort는 주어진 List를 특정 조건에 따라 정렬 가능하다.

• 정렬 조건은 map의 두 키 o1과 o2의 value인 (totalPlays.get(o1)과 totalPlays.get(o2))을 기준으로 한다.
• (o1, o2) -> totalPlays.get(o2) - totalPlays.get(o1)는 내림차순 정렬을 나타낸다.
  • totalPlays.get(o2)이 더 크다면 음수를 반환해 o2가 먼저 오도록 정렬.
  • totalPlays.get(o1)이 더 크다면 양수를 반환해 o1이 나중에 오도록 정렬.

Java의 Comparator는 정렬 기준을 정의할 때 조건이 양수를 반환할 경우 o1이 o2보다 뒤에 가게 된다.

정렬된 map을 기반으로 순회하며 앨범에 넣을 곡을 선택한다.

장르 내에서 가장 많이 재생된 노래를 넣기 위해 다시 정렬을 수행한다.

List<Integer> sortedMap = new ArrayList(map.keySet());
Collections.sort(sortedMap, (o1 , o2) -> map.get(o2) - map.get(o1));

여기서의 map 변수에는 genre에 해당하는 곡들의 정보가 존재하는데

key는 곡의 고유번호가 되고, value는 해당 곡의 재생 횟수가 된다.

마찬가지로 key 값에 해당하는 값을 가져와 ArrayList로 변환하여 정렬을 수행한다.

key 값들을 가져와 key에 해당하는 value를 기준으로 map을 내림차순 정렬한다.

정렬된 값을 기반으로 index에 해당하는 map의 key 값을 answer에 넣어주면 된다.

[코드]

import java.util.*;

class Solution {
    public int[] solution(String[] genres, int[] plays) {
        ArrayList<Integer> answer = new ArrayList<>();

        int len = genres.length;
        Map<String, Integer> totalPlays = new HashMap<>();
        //key : genre, value < Key : idx, value : play>>
        Map<String, HashMap<Integer , Integer>> genreInfo = new HashMap<>();

        for(int idx =0 ; idx<len ; idx++){
            String genre = genres[idx];
            int play = plays[idx];
            if(!genreInfo.containsKey(genre)) {
                HashMap<Integer, Integer> map = new HashMap<>();
                map.put(idx, play);
                genreInfo.put(genre, map);
            } else {
                genreInfo.get(genre).put(idx , play);
            }
            totalPlays.put(genre, totalPlays.getOrDefault(genre, 0) + play);
        }

        List<String> keySet = new ArrayList(totalPlays.keySet());
        //  map을 value 기준으로 정렬
        Collections.sort(keySet, (o1 , o2) -> totalPlays.get(o2) - totalPlays.get(o1));

        for(String key : keySet) {
            Map<Integer, Integer> map = genreInfo.get(key);

            List<Integer> sortedMap = new ArrayList(map.keySet());
            Collections.sort(sortedMap, (o1 , o2) -> map.get(o2) - map.get(o1));

            answer.add(sortedMap.get(0));
            if(sortedMap.size() > 1) {
                answer.add(sortedMap.get(1));
            }
        } 
        return answer.stream().mapToInt(i -> i).toArray();
    }
}

[문제]

https://school.programmers.co.kr/learn/courses/30/lessons/42579

[풀이]

문제는 각 선수 간의 경기 결과를 통해 명확히 순위를 알 수 있는 선수의 수를 구하는 것이다.

플로이드 워셜 알고리즘을 이용해 모든 선수 간의 관계를 구하고, 승패 관계를 기반으로 순위를 계산해준다.

아래 3단계를 통해 순위를 알 수 있는 선수의 수를 구했다.

1. 승패 관계 초기화

• graph 라는 2차원 배열을 선언해 선수 간의 승패 여부를 관리
• i가 j를 이기면 graph[i][j]가 1, 지면 graph[i][j]가 -1

2. 플로이드 워셜 알고리즘

• 중간 노드를 거쳐 갈 수 있는 승패 관계를 업데이트 한다.
• 예를 들어, A → B, B → C라면 A → C 관계를 유추할 수 있다.

3. 순위 확정

• 한 선수에 대해 승리한 선수와 패배한 선수의 합이 n-1이면 해당 선수의 순위를 알 수 있다.

[코드]

class Solution {
    public int solution(int n, int[][] results) {
        int[][] graph = new int [n+1][n+1];
        int answer = 0;
        for(int [] res : results) {
            int winner = res[0];
            int loser = res[1];
            graph[winner][loser] = 1;
            graph[loser][winner] = -1;
        }

        for (int k = 1; k <= n; k++) {
            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= n; j++) {
                    if (graph[i][k] == 1 && graph[k][j] == 1) {
                        graph[i][j] = 1;
                    } else if (graph[i][k] == -1 && graph[k][j] == -1) {
                        graph[i][j] = -1;
                    }
                }
            }
        }

        for(int i=1;i<=n;i++){
            int cnt=0;
            for(int j=1;j<=n;j++){
                if(graph[i][j] == 1 || graph[i][j] == -1)   cnt++;
            }
            if(cnt == n-1)  answer++;
        }
        return answer;
    }
}

[문제]

https://school.programmers.co.kr/learn/courses/30/lessons/49191

[풀이]

1번 노드에서 가장 멀리 떨어진 노드의 갯수를 구하는 문제로

1번 노드에서 나머지 모든 노드까지의 거리를 구해야 한다.

따라서 bfs 알고리즘을 사용해 시작 노드에서부터 각 노드까지의 거리를 구할 수 있었다.

1번 노드에서부터의 각 노드간 거리 정보를 저장하기 위해 일차원 배열인 len도 선언하였다. 

1. 2차원 배열인  graph를 선언하여 각 노드 간의 연결 정보를 저장

2. queue를 선언하여 첫번째 노드와 각 노드간의 거리를 계산

• 처음에 시작 노드인 1번 노드를 queue에 넣어준다.
•  queue가 empty가 될 때 까지 아래 로직을 수행
  • queue에서 최상단에 있는 노드를 pop 꺼내어 해당 노드와 연결된 노드들을 방문
  • 각 노드까지의 거리는 이전 노드까지의 거리 + 1이 된다.
  • 중복 방문을 체크하기 위해 visited 배열도 선언해주었다

위와 같은 방법으로 1번 노드부터 각 노드까지의 거리를 구하였다.

3. 각 노드의 거리를 내림차순으로 정렬하면 배열의 첫번째에 가장 멀리 떨어진 노드의 거리가 존재한다.

• maxLen과 동일한 거리들의 개수를 count하여 answer 값에 더해주었다.

[코드]

import java.util.*;

class Solution {
    public int solution(int n, int[][] edge) {
        ArrayList<Integer>[] graph = new ArrayList[n+1];

        for(int i=1; i<=n; i++) {
            graph[i] = new ArrayList<>();
        }

        int[] len = new int[n+1];

        for(int[] e : edge){
            graph[e[0]].add(e[1]);
            graph[e[1]].add(e[0]);
        }
        
        Queue<Integer> q = new LinkedList<>();
        boolean visited[] = new boolean[n+1];
        
        q.add(1);
        visited[1] = true;

        while(!q.isEmpty()){
            int node = q.poll();
            for(int next : graph[node]) {
                if(!visited[next]){
                    len[next] = len[node] + 1;
                    visited[next] = true;
                    q.add(next);
                }
            }
        }

        Arrays.sort(len);
        int maxLen = len[n];
        int answer = 0;

        for(int idx = n ; idx>0 ; idx--) {
            if(len[idx] == maxLen)  answer++;
            else break;
        }


        return answer;
    }
}

[문제]

https://school.programmers.co.kr/learn/courses/30/lessons/49189

[풀이]

이 문제는 이진 탐색(Binary Search)을 활용하여 효율적으로 해결할 수 있다.

문제의 핵심은 각 심사관의 처리 속도(times 배열)와 사람 수(n)를 고려하여, 모든 사람이 심사를 받을 수 있는 최소 시간을 계산하는 것이다.

최소 시간을 구하기 위해서 시간의 범위를 탐색해야 한다.

이 때 시간을 직접 하나씩 늘려가며 확인하는 완전 탐색은 비효율적이다.

심사를 받는데 걸리는 최소/최대 시간을 아래와 같이 설정할 수 있으므로 탐색의 범위가 좁혀진다.

따라서 이진 탐색을 생각하게 된다.

• 최소 시간: 1분 (최소한의 시간)
• 최대 시간: 가장 느린 심사관이 모든 사람을 처리하는 경우 n×max(times)

이진 탐색은 정렬된 범위에서 특정 조건을 만족하는 최적의 값을 찾는 문제에 적합하다.

이진 탐색 알고리즘에 대한 자세한 설명은 아래 링크를 통해 확인할 수 있습니다.

https://tnwlswkd.tistory.com/112

이진 탐색을 구현하기 위해 

low 값을 최소 시간, high 값을 최대 시간으로 설정해두었다.

그리고  calcPersonCount에서  mid에 해당하는 시간에 총 몇명을 심사할 수 있는지 계산했다.

이 때 아래 사진과 같은 문제를 해결하기 위해 심사 가능한 사람이 이미 n명을 넘었다면 반복문을 빠져나오도록 했다.

mid 시간에 해결할 수 있는 사람이 n명 보다 많으면 더 짧은 시간을 탐색하기 위해 high 값을  mid -1로 업데이트 하고

n명보다 적으면 더 긴시간을 탐색하기 위해 low 를 mid + 1 로 업데이트 해주었다.

personCnt == n인 경우에도 탐색을 계속하는 이유는 더 작은 시간에서 조건을 만족하는지를 확인하기 위해서이다.

위의 과정을 반복하며 모든 사람을 심사하기 위한 최소시간을 계산해주었다.

[시간 복잡도]

[코드]

import java.util.Arrays;

class Solution {
    public long solution(int n, int[] times) {
        long low = 1;
        long high = (long) Arrays.stream(times).max().getAsInt() * n; 
        long answer = high;

        while(low <= high) {
            long mid = (low + high) / 2;
            long personCnt = calcPersonCount(mid,n,times);
            if(personCnt >= n) {
                answer = mid;
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return answer;
    }

    public long calcPersonCount(long curTime ,int n, int[] times){
        long personCnt = 0;
        for(int time : times) {
            personCnt += curTime / time;
            if(personCnt > n)   break;
        }
        return personCnt;
    }
}

[문제]

https://school.programmers.co.kr/learn/courses/30/lessons/43238

[풀이]

해당 문제는 모든 섬들을 최소 비용으로 연결하는 문제이므로 크루스칼 알고리즘을 사용해 풀 수 있다.

크루스칼 알고리즘이란 모든 노드들을 최소 비용으롤 연결하는 알고리즘이다.

아래 링크에서 크루스칼 알고리즘에 대해 자세한 설명을 볼 수 있다.
https://tnwlswkd.tistory.com/42

최소 비용을 계산하기 위해 우선 두 섬을 연결하는 다리를 건설할 때 드는 비용을 기준으로 오름차순 정렬을 해주었다.

이 때 각 비용은 cost 배열의 2번째 배열에 존재하기 때문에 Arrays.sort 메서드와 Comparator를 사용했다.

연결을 하기 전엔 각자의 부모를 자기 자신으로 초기화한다.

그리고 최소 비용부터 cost를 순회하며 현재 섬의 부모가 같은 지 확인 후 

다를 경우 섬을 연결해준다.

[코드]

import java.util.Arrays;

class Solution {
    static int[] parent;
	
    public int solution(int n, int[][] costs) {
        int answer = 0;
    
    	Arrays.sort(array, (a, b) -> Integer.compare(a[1], b[1]));

        for(int idx=0;idx<n;idx++) { 
            parent[idx]=idx;
        }
        for(int[] cost : costs) {
            int from  = cost[0];
            int to = cost[1];
            int len = cost[2];

            if(Find(from) == Find(to)) continue;
            Union(from, to);
            answer+=len;
        }

        return answer;
    }
    
    public int Find(int idx) {
        if(parent[idx] == idx)  return idx;
        else {
            return Find(parent[idx]);
        }
    }

    public void Union(int idx1, int idx2) {
        int parent1 = Find(idx1);
        int parent2 = Find(idx2);

        parent[parent2] = parent1;
    }
}

[문제]

https://school.programmers.co.kr/learn/courses/30/lessons/42861

[풀이]

야근 피로도를 최소화 하는 문제다.

야근 피로도는 남은 작업량을 제곱하여 더한 값이기 때문에

남은 작업량 중에서 작업량이 가장 큰 값부터 빼주면 된다.

따라서 우선순위 큐를 사용했는데 reverseOrder를 사용해 내림차순이 되도록 하였다.

해당 큐에 남은 작업량들을 넣어주어 가장 큰 값부터 1씩 빼주도록 하였다

해당 작업을 퇴근까지 남은 시간인 N번만큼 수행하도록 하였다.

위의 작업들을 마무리 하고 큐에 남은 값들을 제곱들하여 다 더해주었다.

[코드]

import java.util.Collections;
import java.util.PriorityQueue;

class Solution {
    public long solution(int n, int[] works) {
        long answer = 0;
        PriorityQueue<Integer> leftWork = new PriorityQueue<>(Collections.reverseOrder());
        for(int work : works) {
            leftWork.offer(work);
        }
        for(int idx=0;idx<n;idx++){
            if(leftWork.size() == 0)    break;
            int work = leftWork.poll() - 1;
            if(work > 0) {
                leftWork.offer(work);
            }
        }
        for(int work : leftWork){
            answer += work*work;
        }
        return answer;
    }
}

[문제]

https://school.programmers.co.kr/learn/courses/30/lessons/12927

[풀이]

문제 조건에서 이모티콘의 최대 개수가 7개밖에 되지 않기 때문에 안심하며 완전탐색을 사용해 풀었다.

각 이모티콘별 할인율을 저장하기 위한 discountRate 변수를 선언했다.

setDiscountRate 함수를 통해 각 이모티콘별 할인율을 10프로에서 40프로까지 모든 경우의 수를 돌리도록 지정해줬다.

해당 함수를 통해 각 이모티콘별 할인율을 정해주고 , 모든 이모티콘에 대해 할인율이 정해졌으면 calcPrice 함수를 호출한다.

calcPrice 함수에서는 각 사용자마다 이모티콘 총 구매 금액을 계산했다.

각 사용자들은 자신의 기준에 따라 일정 비율 이상 할인하는 이모티콘들에 할인 가격을 계산하여 price 변수에 더해준다.

모든 이모티콘들에 대해 계산이 끝나면 

각 사용자들은 자신의 기준에 따라 이모티콘 구매 비용의 합이 일정 가격 이상이 된다면 

emoticonPlus(이모티콘 플러스 구매한 사용자 수)에 1을 더해주고 

일정 가격 이상이 되지 않는다면 emoticonPrice에 이모티콘 구매 가격을 더해주었다.

1. 이모티콘 플러스 사용자 수 최대

2. 이모티콘 판매액 최대

위의 우선순위를 기준으로 이모티콘 플러스 사용자 수와 구매 가격을 계산해주었다.

[시간 복잡도]

주어진 문제의 조건을 기반으로 시간 복잡도를 계산해보면 

1. 완전 탐색

• 각 이모티콘은 4가지 할인율(10%, 20%, 30%, 40%) 중 하나를 선택할 수 있다.
• 이모티콘 개수를 N이라고 하면, 할인율 조합의 경우의 수는 

2. calcPrice 함수

• 모든 유저에 대해 반복 (users.length = M)
• 각 유저에 대해 이모티콘 개수 만큼 반복 (emoticons.length = N)

따라서 calcPrice의 시간 복잡도는 

𝑂(𝑀×𝑁)

3. 전체 시간 복잡도

[코드]

class Solution {
    static final int MAX_EMOTICON = 7;
    static int MAX_USER = 0;
    static int MAX_PRICE = 0;
    static int[] discountRate = new int[MAX_EMOTICON];

    public int[] solution(int[][] users, int[] emoticons) {

        setDiscountRate(0,users, emoticons);
        int[] answer = {MAX_USER ,MAX_PRICE};
        return answer;
    }

    public void setDiscountRate(int curIdx, int[][] users, int[] emoticons) {
        if(curIdx == emoticons.length) {
            calcPrice(users,emoticons);
            return;
        }
        for(int i = 10; i<= 40 ; i+=10) {
            discountRate[curIdx] = i;
            setDiscountRate(curIdx+1, users, emoticons);
        }
    }

    public void calcPrice(int[][] users, int[] emoticons) {

        int emoticonPlus=0;
        int emoticonPrice=0;

        for(int[] user : users) {
            // 각 유저의 이모티콘 구매 금액
            int price=0;
            int userDiscountRate = user[0];
            int userPlusPrice = user[1];
            for(int idx=0; idx<emoticons.length; idx++) {
                if(discountRate[idx] >= userDiscountRate) {
                    price += (emoticons[idx]/100) * (100-discountRate[idx]); 
                }
            }
            if(price >= userPlusPrice) {
                emoticonPlus++;
            } else {
                emoticonPrice += price;
            }
        }

        if(emoticonPlus > MAX_USER) {
            MAX_USER = emoticonPlus;
            MAX_PRICE = emoticonPrice;
        } 
        else if ( emoticonPlus == MAX_USER && emoticonPrice >= MAX_PRICE)   MAX_PRICE = emoticonPrice;
    }
}

[문제]

https://school.programmers.co.kr/learn/courses/30/lessons/150368