코딩테스트 합격을 위한 변수명과 함수명 짓는 완벽 가이드

대부분의 개발자가 처음 코딩테스트를 준비할 때 간과하기 쉬운 부분이 있습니다. 바로 변수명과 함수명을 짓는 방식입니다. 많은 사람들이 알고리즘 해결 자체에만 집중하다 보니 코드의 가독성이나 네이밍 컨벤션을 무시하곤 합니다. 하지만 진정한 의미에서 "좋은 코드"를 작성하려면, 변수명과 함수명을 얼마나 명확하고 일관성 있게 짓는지가 매우 중요합니다. 실제로 코딩테스트 면접을 진행하는 면접관들도 코드의 가독성을 평가하는 항목으로 포함시키는 경우가 많습니다. 오늘은 제가 코딩테스트를 준비하면서 배운 변수명과 함수명을 잘 짓는 노하우에 대해 여러분들과 공유하려고 합니다.

왜 변수명과 함수명이 중요한가?

저는 처음 코딩테스트를 시작했을 때 변수명을 a, b, c 같은 단일 문자로 짓거나, temp, res, ans 같은 약자로 지었습니다. 코드는 빠르게 작성되었지만, 한 시간 후에 내가 짠 코드를 다시 읽으려고 하면 무엇을 하는 코드인지 파악하기가 어려웠습니다. 더 심각한 문제는 코드 리뷰를 받을 때였습니다. 누군가 내 코드를 봤을 때 "이 변수가 정확히 무엇을 의미하는 건가요?"라는 질문을 받으면 설명에 많은 시간을 소비해야 했습니다.

 
변수명과 함수명이 좋다는 것은 단순히 길다는 뜻이 아닙니다. 코드를 읽는 사람이 변수명과 함수명만 봐도 그것이 무엇을 하는지, 어떤 데이터를 담는지 명확하게 이해할 수 있어야 한다는 뜻입니다. 코드는 사람이 읽기 위한 것이고, 기계는 부수적으로 실행할 뿐입니다. 이 원칙을 명심하면 자연스럽게 좋은 네이밍이 나옵니다.

변수명을 지을 때 지켜야 할 기본 원칙들

1. 의도를 명확하게 드러내라

변수명을 지을 때 가장 중요한 원칙은 "의도의 명확성"입니다.
예를 들어보겠습니다.

// 나쁜 예
int d;
int elapsedTime;
String s;

// 좋은 예
int daysSinceCreation;
int elapsedTimeInDays;
String userName;

첫 번째 예시의 d는 무엇을 의미하는지 전혀 알 수 없습니다. 하지만 daysSinceCreation이라고 작성하면 변수명만으로도 이 변수가 생성된 이후로 경과한 일수라는 것을 즉시 파악할 수 있습니다. 특히 코딩테스트에서는 시간 제약이 있으므로, 나중에 코드를 다시 읽을 때 변수의 의미를 파악하는 데 드는 인지 비용을 최소화하는 것이 중요합니다.

 

2. 그릇된 정보를 피하라

변수명에 잘못된 단서를 남기면 안 됩니다. 예를 들어, 리스트 형태의 여러 객체를 담는 변수를 지을 때 주의해야 합니다.

// 나쁜 예
List<Integer> accountList; // 실제로는 Set이지만 List라고 이름을 지음
String phoneNumberString; // 이미 String 타입인데 타입을 중복으로 표현

// 좋은 예
List<Integer> accounts;
String phoneNumber;

변수명에 타입 정보를 굳이 포함시킬 필요는 없습니다. IDE가 타입을 보여주기 때문입니다. 오히려 이렇게 하면 나중에 타입이 변경될 때마다 변수명까지 수정해야 하는 번거로움이 생깁니다.
 

3. 의미 있게 구분하라

// 나쁜 예
int count1;
int count2;
int countTemp;

List<String> data;
List<String> information;

// 좋은 예
int totalCount;
int processedCount;
int currentIndex;

List<String> userNames;
List<String> productIds;

변수들 사이의 차이가 명확해야 합니다. count1과 count2는 무엇이 다른지 알 수 없지만, totalCount와 processedCount라고 하면 역할이 명확합니다.

 

4. 발음하기 쉬운 이름을 사용하라

// 나쁜 예
Date genymdhms;  // 발음하기 어려움
String pszqint;  // 약자만으로 구성되어 의미 파악이 어려움

// 좋은 예
Date generationTimestamp;
String recordId;

약자를 많이 사용한 변수명은 그것을 처음 보는 사람에게 혼란을 줍니다.
 

5. 검색하기 쉬운 이름을 사용하라

// 나쁜 예
int a;
int i;  // 매우 짧아서 검색하면 수많은 결과가 나옴

// 좋은 예
int arrayIndex;
int elementCount;

단일 문자나 흔한 약자를 사용하면 검색할 때 관련 없는 결과까지 함께 나타나 효율성이 떨어집니다.

네이밍 컨벤션: 언어별 관습을 따르자

프로그래밍 언어마다 변수명과 함수명을 짓는 관습이 있습니다. 코딩테스트에서는 주로 Java, Python, C++ 중 하나를 사용하게 되므로, 선택한 언어의 관습을 따르는 것이 중요합니다.
 

Java의 네이밍 컨벤션

// 변수: camelCase 사용
int studentCount;
String lastName;
boolean isValid;

// 상수: 모두 대문자, 언더스코어로 구분
static final int MAX_SIZE = 100;
static final String DEFAULT_NAME = "Anonymous";

// 클래스: PascalCase 사용
class StudentManager { }
class DataProcessor { }

// 메서드: camelCase로 시작, 동사 우선
void processData();
boolean validateInput();

Python의 네이밍 컨벤션

# 변수와 함수: snake_case 사용
student_count = 0
def process_data():
    pass

# 상수: 모두 대문자, 언더스코어로 구분
MAX_SIZE = 100

# 클래스: PascalCase 사용
class StudentManager:
    pass

C++의 네이밍 컨벤션

// 변수: camelCase 또는 snake_case
int studentCount;
string lastName;

// 상수: 모두 대문자
const int MAX_SIZE = 100;

// 함수: camelCase 또는 snake_case
void processData();
bool validateInput();

이렇게 각 언어의 관습을 따르면, 코드가 그 언어의 표준을 따르는 깔끔한 코드로 보입니다.

함수명을 지을 때의 노하우

함수명은 변수명보다 더 신중하게 지어야 합니다. 함수명은 그 함수가 무엇을 하는지 명확하게 표현해야 하기 때문입니다.
 

1. 함수명은 동사로 시작하라

// 나쁜 예
void userData();  // 동사가 없어서 무엇을 하는지 불명확
List<Integer> numbers();

// 좋은 예
void loadUserData();
List<Integer> getSortedNumbers();
void calculateTotal();

동사를 사용하면 함수가 무엇을 하는지 명확해집니다.
 

2. 조건을 확인하는 함수는 is, has, can으로 시작하라

// 나쁜 예
boolean valid();  // 단순한 형용사로 시작
boolean check();  // 동사지만 무엇을 확인하는지 불명확

// 좋은 예
boolean isValid();
boolean hasNext();
boolean canProcess();

is, has, can 같은 접두사를 사용하면 함수가 boolean을 반환한다는 것을 한눈에 파악할 수 있습니다.

 

3. 함수명에 함수가 하는 일을 정확히 드러내라

// 나쁜 예
void process();  // 너무 광범위하고 불명확
void handle();   // 무엇을 처리하는지 모름

// 좋은 예
void sortStudentsByGrade();
void filterActiveUsers();
void calculateAverageScore();

함수명에 함수가 대상으로 삼는 데이터와 그것을 어떻게 처리하는지 명확하게 표현해야 합니다.
 

4. 비슷한 개념에는 일관된 단어를 사용하라

// 나쁜 예
User getUserById();
Student fetchStudentByName();
Product retrieveProductById();

// 좋은 예
User getUserById();
Student getStudentByName();
Product getProductById();

get, fetch, retrieve 같은 단어들은 비슷한 의미지만, 같은 개념에는 같은 단어를 사용해야 혼란을 줄일 수 있습니다.

실무 팁: SMART 원칙

코드 가독성을 높이기 위한 SMART 원칙이 있습니다. 변수명이나 함수명이 다음 조건을 충족하는지 확인해보세요.
 

S: Searchable (검색이 쉽다)

• 단일 문자나 너무 짧은 이름은 피하기
• Ctrl+F로 검색했을 때 원하는 것만 나오도록

M: Mixable (조합하기 쉽다)

• 다른 이름과 함께 사용할 때 일관성 있도록
• 관련된 변수들끼리 연관성 있게 지으면 코드 리뷰할 때 함께 이해됨

A: Agreeable (모두가 수긍한다)

• 팀 내 코딩 컨벤션을 따르기
• 이상한 약자나 개인적인 습관 피하기

R: Rememberable (기억하기 쉽다)

• 처음 보는 사람도 의미를 쉽게 파악할 수 있도록
• 일반적인 용어 사용하기

T: Typeable (입력하기 쉽다)

• 너무 길지 않으면서도 명확하도록
• 특수문자나 언더스코어를 너무 많이 사용하지 않기

이 원칙들을 모두 충족할 필요는 없지만, 적어도 처음 세 가지(Searchable, Mixable, Agreeable)는 반드시 지켜야 합니다.

코딩테스트에서 실제로 적용하는 예시

제가 실제로 코딩테스트를 준비할 때 작성한 코드의 변화 과정을 보여드리겠습니다.
 

첫 번째 시도 - 나쁜 예시

class Solution {
    public int[] solution(int[] arr, int k) {
        int[] res = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            int temp = arr[i];
            if (temp > k) {
                res[i] = 1;
            } else {
                res[i] = 0;
            }
        }
        return res;
    }
}

이 코드는 동작하지만 가독성이 떨어집니다. res가 무엇인지, k가 무엇인지, temp의 역할이 무엇인지 명확하지 않습니다.

 

두 번째 시도 - 개선된 예시

class Solution {
    public int[] solution(int[] inputArray, int threshold) {
        int[] result = new int[inputArray.length];
        for (int i = 0; i < inputArray.length; i++) {
            int currentValue = inputArray[i];
            if (currentValue > threshold) {
                result[i] = 1;
            } else {
                result[i] = 0;
            }
        }
        return result;
    }
}

훨씬 더 명확해졌습니다. 하지만 추가로 개선할 부분이 있습니다.
 

세 번째 시도 - 최적화된 예시

class Solution {
    public int[] solution(int[] inputArray, int threshold) {
        int arrayLength = inputArray.length;
        int[] binaryResult = new int[arrayLength];
        
        for (int index = 0; index < arrayLength; index++) {
            binaryResult[index] = isGreaterThanThreshold(inputArray[index], threshold) ? 1 : 0;
        }
        return binaryResult;
    }
    
    private boolean isGreaterThanThreshold(int value, int threshold) {
        return value > threshold;
    }
}

이제 코드의 의도가 매우 명확합니다. 심지어 함수명만 읽어도 이 코드가 무엇을 하는지 알 수 있습니다. 면접관도 이런 코드를 보면 긍정적인 평가를 할 가능성이 높습니다.

자주 하는 실수들

코딩테스트를 준비하면서 많은 사람들이 같은 실수를 반복합니다. 제가 자주 본 패턴들을 정리했습니다.
 

1. 단일 문자 변수를 남용하기

// 피해야 할 패턴
for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
        int a = arr[i][j];
        int b = a * 2;
        res[i][j] = b;
    }
}

// 개선된 패턴
for (int row = 0; row < rowCount; row++) {
    for (int col = 0; col < colCount; col++) {
        int originalValue = matrix[row][col];
        int doubledValue = originalValue * 2;
        result[row][col] = doubledValue;
    }
}

루프 변수는 i, j를 사용해도 괜찮지만, 실제 데이터를 담는 변수는 명확한 이름을 사용해야 합니다.

 

2. 약자를 너무 많이 사용하기

// 나쁜 예
int tC;  // totalCount?
int pCnt;  // processCount?
String dn;  // displayName?

// 좋은 예
int totalCount;
int processCount;
String displayName;

약자의 의미를 변수명만으로 파악하기 어렵습니다.
 

3. 변수명에 타입 정보 포함하기

// 나쁜 예
int countInt;
String nameString;
List<User> userList;

// 좋은 예
int count;
String name;
List<User> users;

IDE가 타입을 보여주므로 중복할 필요가 없습니다.
 
변수명과 함수명을 잘 짓는 것은 단순해 보이지만 실제로는 매우 중요한 기술입니다. 특히 코딩테스트 면접에서는 문제 해결 능력뿐만 아니라 코드의 품질도 평가합니다. 처음에는 시간이 걸릴 수 있지만, 계속 연습하다 보면 자연스럽게 좋은 이름을 짓는 능력이 생깁니다.
 
저는 매일 새로운 문제를 풀 때마다 변수명과 함수명에 신경을 씁니다. 때로는 완벽한 이름을 찾기 위해 몇 분을 고민하기도 합니다. 하지만 나중에 코드를 다시 읽거나, 누군가 내 코드를 리뷰할 때 그 노력이 빛납니다. 여러분도 이번 글에서 배운 원칙들을 바탕으로 더 좋은 코드를 작성하시길 바랍니다. 무엇보다 중요한 것은 일관성입니다. 정해진 규칙을 끝까지 지키려는 노력이 결국 여러분을 좋은 개발자로 만들 것입니다.
 
코딩테스트 준비 중에 변수명과 함수명에 대해 고민이 생기면, 이 글의 SMART 원칙과 각 언어의 네이밍 컨벤션으로 돌아와 확인해보세요. 그리고 항상 기억하세요. 좋은 코드는 컴퓨터가 아닌 사람을 위해 작성되는 것입니다. 자신이 짠 코드를 한 달 후에 다시 읽어도 이해할 수 있도록, 그리고 처음 보는 사람도 쉽게 파악할 수 있도록 성의 있는 네이밍을 해주시길 권장합니다. 여러분의 코딩테스트 합격을 응원합니다!

입사 코딩테스트 준비할 때 ‘주석’과 ‘가독성’ 좋은 코드 작성 실전 팁