Home > CS > 2025 > πŸ’Ύ 논리 μ—°μ‚° - λΆˆλ¦¬μ–Έ λŒ€μˆ˜

πŸ’Ύ 논리 μ—°μ‚° - λΆˆλ¦¬μ–Έ λŒ€μˆ˜
CS

πŸ’Ύ 논리 μ—°μ‚° - λΆˆλ¦¬μ–Έ λŒ€μˆ˜

β€œν•œ ꢌ으둜 μ½λŠ” 컴퓨터 ꡬ쑰와 ν”„λ‘œκ·Έλž˜λ°β€ 쀑 λΆˆλ¦¬μ–Έ λŒ€μˆ˜ 파트 μš”μ•½


κΈ°λ³Έ κ°œλ…

λΆˆλ¦¬μ–Έ λŒ€μˆ˜λž€?

1800λ…„λŒ€ 영ꡭ μˆ˜ν•™μž μ‘°μ§€ 뢈(George Boole)이 λ§Œλ“€μ–΄λ‚Έ λΆˆλ¦¬μ–Έ λŒ€μˆ˜(Boolean algebra)λŠ” λΉ„νŠΈμ— λŒ€ν•΄ μ‚¬μš©ν•  수 μžˆλŠ” μ—°μ‚° κ·œμΉ™μ˜ μ§‘ν•©μž…λ‹ˆλ‹€.

λΆˆλ¦¬μ–Έ λŒ€μˆ˜μ˜ νŠΉμ§•

  • 일반 λŒ€μˆ˜μ™€μ˜ μœ μ‚¬μ„±: κ²°ν•© 법칙, κ΅ν™˜ 법칙, λΆ„λ°° 법칙 적용 κ°€λŠ₯
  • λΉ„νŠΈ μ—°μ‚°μ˜ 체계화: 0κ³Ό 1(κ±°μ§“κ³Ό μ°Έ)에 λŒ€ν•œ 논리적 μ—°μ‚° κ·œμΉ™ 제곡
  • 컴퓨터 κ³Όν•™μ˜ 기초: λͺ¨λ“  λ””μ§€ν„Έ νšŒλ‘œμ™€ ν”„λ‘œκ·Έλž˜λ° λ…Όλ¦¬μ˜ κ·Όκ°„

κΈ°λ³Έ λΆˆλ¦¬μ–Έ μ—°μ‚°μž

μ—°μ‚°μž κ°œμš”

μ—°μ‚°μž 기호 의미 ν”Όμ—°μ‚°μž 수
NOT ~ λ˜λŠ” ! 논리적 λ°˜λŒ€ 1개
AND & λ˜λŠ” && 논리곱 2개 이상
OR | λ˜λŠ” || 논리합 2개 이상
XOR ^ 배타적 논리합 2개

NOT μ—°μ‚° (논리적 λ°˜λŒ€)

μž…λ ₯ 좜λ ₯
0 (κ±°μ§“) 1 (μ°Έ)
1 (μ°Έ) 0 (κ±°μ§“)

μ˜ˆμ‹œ:

  • NOT(κ±°μ§“) = μ°Έ
  • NOT(μ°Έ) = κ±°μ§“

AND μ—°μ‚° (논리곱)

A B A AND B
0 0 0
0 1 0
1 0 0
1 1 1

κ·œμΉ™: λͺ¨λ“  λΉ„νŠΈκ°€ 참일 λ•Œλ§Œ κ²°κ³Όκ°€ μ°Έ

OR μ—°μ‚° (논리합)

A B A OR B
0 0 0
0 1 1
1 0 1
1 1 1

κ·œμΉ™: μ–΄λŠ ν•œ λΉ„νŠΈλΌλ„ 참이면 κ²°κ³Όκ°€ μ°Έ

XOR μ—°μ‚° (배타적 논리합)

A B A XOR B
0 0 0
0 1 1
1 0 1
1 1 0

κ·œμΉ™: 두 λΉ„νŠΈκ°€ λ‹€λ₯Έ 값일 λ•Œλ§Œ κ²°κ³Όκ°€ μ°Έ


ν”„λ‘œκ·Έλž˜λ°μ—μ„œμ˜ ν™œμš©

Javaμ—μ„œμ˜ λΆˆλ¦¬μ–Έ μ—°μ‚°

// 논리 μ—°μ‚°μž μ‚¬μš© μ˜ˆμ‹œ
boolean isRaining = true;
boolean isCold = false;
boolean hasUmbrella = true;

// AND μ—°μ‚°
boolean takeUmbrella = isRaining && hasUmbrella;  // true

// OR μ—°μ‚°
boolean wearCoat = isRaining || isCold;  // true

// NOT μ—°μ‚°
boolean goOutside = !isRaining;  // false

// XOR μ—°μ‚° (λΉ„νŠΈ λ‹¨μœ„)
int result = 5 ^ 3;  // 6 (101 XOR 011 = 110)

쑰건뢀 λ‘œμ§μ—μ„œμ˜ ν™œμš©

// 볡합 쑰건 검사
public boolean canProcessOrder(Order order) {
    return order.isValid() && 
           order.hasPayment() && 
           !order.isCancelled();
}

// κΆŒν•œ 검사
public boolean hasAccess(User user, Resource resource) {
    return user.isAdmin() || 
           (user.isActive() && resource.isPublic());
}

λΆˆλ¦¬μ–Έ λŒ€μˆ˜μ˜ 법칙

κΈ°λ³Έ 법칙듀

법칙 곡식 μ„€λͺ…
κ΅ν™˜ 법칙 A AND B = B AND A μˆœμ„œλ₯Ό 바꿔도 κ²°κ³Ό 동일
κ²°ν•© 법칙 (A AND B) AND C = A AND (B AND C) κ·Έλ£Ήν™” μˆœμ„œ 무관
λΆ„λ°° 법칙 A AND (B OR C) = (A AND B) OR (A AND C) κ³±μ…ˆκ³Ό λ§μ…ˆμ˜ 뢄배와 μœ μ‚¬

특수 법칙듀

ν•­λ“± 법칙:
A AND 1 = A
A OR 0 = A

영 법칙:
A AND 0 = 0
A OR 1 = 1

보수 법칙:
A AND NOT(A) = 0
A OR NOT(A) = 1

μ‹€μƒν™œ 적용 μ˜ˆμ‹œ

μ›Ή μ• ν”Œλ¦¬μΌ€μ΄μ…˜ μ ‘κ·Ό μ œμ–΄

public class AccessControl {
    public boolean canAccessAdminPanel(User user) {
        return user.isAdmin() && 
               user.isActive() && 
               !user.isLocked();
    }
    
    public boolean canViewContent(User user, Content content) {
        return content.isPublic() || 
               (user.isLoggedIn() && content.isUserContent(user));
    }
}

데이터 μœ νš¨μ„± 검사

public boolean isValidEmail(String email) {
    return email != null && 
           email.contains("@") && 
           !email.isEmpty() && 
           email.length() > 5;
}

λΉ„νŠΈ λ‹¨μœ„ μ—°μ‚°μ˜ ν™œμš©

ν”Œλž˜κ·Έ 관리

// κΆŒν•œ ν”Œλž˜κ·Έ μ •μ˜
public static final int READ = 1;    // 001
public static final int WRITE = 2;   // 010
public static final int EXECUTE = 4; // 100

// κΆŒν•œ μ„€μ •
int permissions = READ | WRITE;  // 011

// κΆŒν•œ 확인
boolean canRead = (permissions & READ) != 0;    // true
boolean canWrite = (permissions & WRITE) != 0;  // true
boolean canExecute = (permissions & EXECUTE) != 0; // false

// κΆŒν•œ 제거
permissions = permissions & ~WRITE;  // READ만 남김

핡심 포인트

  1. 체계성: λΆˆλ¦¬μ–Έ λŒ€μˆ˜λŠ” 논리 연산에 λŒ€ν•œ μ™„μ „ν•œ μˆ˜ν•™μ  체계
  2. 일관성: 일반 λŒ€μˆ˜μ˜ 법칙듀이 λΆˆλ¦¬μ–Έ λŒ€μˆ˜μ—λ„ 적용됨
  3. μ‹€μš©μ„±: ν”„λ‘œκ·Έλž˜λ°μ˜ 쑰건문과 λΉ„νŠΈ μ—°μ‚°μ˜ 기초
  4. ν™•μž₯μ„±: κΈ°λ³Έ μ—°μ‚°μžλ“€μ„ μ‘°ν•©ν•˜μ—¬ λ³΅μž‘ν•œ 논리 ꡬ쑰 ν‘œν˜„ κ°€λŠ₯
  5. νš¨μœ¨μ„±: 컴퓨터 ν•˜λ“œμ›¨μ–΄μ—μ„œ 직접 κ΅¬ν˜„λ˜μ–΄ 맀우 λΉ λ₯Έ μ—°μ‚° 속도

λΆˆλ¦¬μ–Έ λŒ€μˆ˜λŠ” λ””μ§€ν„Έ μ‹œλŒ€μ˜ λͺ¨λ“  논리적 사고와 컴퓨터 μ—°μ‚°μ˜ κ·Όλ³Έ μ›λ¦¬λ‘œ, ν”„λ‘œκ·Έλž˜λ°μ—μ„œ 쑰건 νŒλ‹¨κ³Ό 데이터 처리의 핡심 λ„κ΅¬μž…λ‹ˆλ‹€.