<24년 3회 1번>
public class Main{
static String[] x = new String[3];
static void func(String[] x, int y) {
for(int i = 1; i < y; i++){
if(x[i-1].equals(x[i])){
System.out.print("O");
}
else{
System.out.print("N");
}
}
for (String z : x){
System.out.print(z);
}
}
public static void main(String[] args){
x[0] = "A";
x[1] = "A";
x[2] = new String("A");
func(x, 3);
}
}
답: OOAAA
반복변수 i가 1에서 1씩 증가하고, x[i-1]과 x[i]가 같으면 O를, 다르면 N을 호출합니다.
.equals()를 사용하면 문자열의 내용(값)이 같은지를 비교하는 것이므로 x[0], x[1]과 x[2]는 같은 것
(.equals() 가 아닌 == 을 사용했다면 false였을 것)
<24년 3회 14번>
public class Main{
public static void main(String[] args){
B a = new D();
D b = new D();
System.out.print(a.getX() + a.X + b.getX() + b.x);
}
}
class B {
int x = 3;
int getX() {
return x * 2;
}
}
class D extends B{
int x = 7;
int getX() {
return x * 3;
}
}
정답: 52
B a = new D() 에서 클래스 형 변환이 발생했으므로 a.getX()는 B.getX()가 아닌 D.getX()
클래스에서의 형 변환은 메소드에 대해서만 발생(변수는 형 변환 대상 x)하므로 a.x=3
따라서 21 + 3 + 21 + 7 = 52
<24년 3월 17번>
public class Main{
public static void main(String[] args) {
int sum = 0;
try{
func();
}
catch (NullPointerException e){
sum = sum + 1;
}
catch (Exception e){
sum = sum + 10;
finally{
sum = sum + 100;
}
System.out.print(sum);
}
static void func() throws Exception{
throw new NullPointerException();
}
}
정답: 101
func() 메소드에서 강제로 NullPointerExeption(Null을 가진 객체를 참조하는 경우 사용하는 예외 객체) 예외를 발생시킵니다. (throw는 강제로 예외를 발생시킵니다)
sum + 1 이후에 try-catch문이 종료되었으므로 finally로 넘어가 + 100을 해줍니다.
<24년 3회 18번>
class Printer{
void print(Integer a){
System.out.print("A" + a);
}
void print(object a){
System.out.print("B" + a);
}
void print(Number a){
System.out.print("C" + a);
}
}
public class Main{
public static void main(String[] args){
new Collection<>(0).print();
}
public static class Collection<T> {
T value;
public Collection(T t){
value = t;
}
public void print() {
new Printer().print(value);
}
}
}
정답: B0
오버로딩과 제너릭 기법에 대한 이해가 필요한 문제입니다.
overloading: print 메소드는 이름은 같고 인수의 자료형이 다르므로 서로 다른 메소드입니다.
Generic: 메소드를 선언할 때 자료형이 정해지지 않고, 생성하거나 호출할 때 정해집니다. (<> 사용)
new Collection<>(0)을 보면 정수를 전달했으므로 T는 integer이지만, 컴파일 과정에서만 유효하고 실행 시에 제거됩니다.
실행 과정에서는 기본 자료형(object) 로 취급되므로 B가 호출됩니다. (T는 자료형, t는 인수이므로 a는 0)
<24년 2회 1번>
public class Test{
public static void main(String[] args){
String str = "ITISTESTSTRING";
String[] result = str.split("T");
System.out.print(result[3]);
}
}
정답: S
T를 기준으로 문자열을 분리합니다. 이 때 분리 기준 문자가 포함되지 x (ST가 아니라 S)
<24년 2회 2번>
public class Test{
public static void check(int[] x, int[] y){
if(x==y) System.print("O");
else System.out.print("N");
}
public static void main(String[] args){
int a[] = new int[] {1, 2, 3, 4);
int b[] = new int[] {1, 2, 3, 4);
int c[] = new int[] {1, 2, 3};
check(a,b);
check(b,c);
check(a,c);
}
}
정답: NNN
은근히(?) 함정 문제 (b,c랑 a,c 비교하기는 쉽지만 a,b가 헷갈릴 수 있음)
a와 b는 값과 상관없이 주소가 다르므로 서로 다른 객체입니다. 따라서 N
<24년 2회 7번>
interface Number{
int sum(int[] a, boolean odd);
}
public class Test{
public static void main(String[] args){
int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
OENumber OE = new OENumber();
System.out.print(OE.sum(a, true) + "," + OE.sum(a,false));
}
}
class OENumber implements Number{
public int sum(int[] a, boolean odd){
int result = 0;
for (int i = 0; i < a.length; i++){
if ((odd && a[i] % 2 != 0) || (!odd && a[i] % 2 == 0)){
result += a[i];
}
}
return result;
}
}
정답: 25, 20
홀수와 짝수의 합을 구하는 문제이므로 흐름을 외워두면 편합니다.
class OENumber 는 Number 인터페이스를 상속받습니다.
OE.sum(a, true)는 홀수의 합, OE.sum(a, false)는 짝수의 합
<24년 2회 8번>
public class Test{
public static String rf(String str, int index, boolean[] seen){
if(index < 0) return "";
char c = str.charAt(index);
String result = rf(str, index - 1, seen);
if(!seen[c]){
seen[c] = true;
return c + result;
}
return result;
}
public static void main(String[] args){
String str = "abacabcd";
int len = str.length();
boolean[] seen = new boolean[256];
System.out.print(rf(str, len-1, seen));
}
}
정답: dcba
문자열의 중복된 문자를 제거하면서 역순으로 새로운 문자열을 생성하는 재귀 함수 입니다.
논리형 배열 요소에는 true/false를 저장할 수 있으며, 기본값은 false입니다.
if(!seen[c])문을 통해 해당 문자가 처음 등장했다면 포함하여 반환하고, 이미 본 문자라면 포함하지 않고 반환합니다.
<24년 1회 1번>
#include <stdio.h>
#include <stdlib.h>
main(int argc, char *argv[]) {
int v1 = 0;
int v2 = 35;
int v3 = 29;
if(v1 > v2 ? v2 : v1)
v2 = v2 << 2;
else
v3 = v3 << 2;
printf("%d", v2 + v3);
return 0;
}
정답: 151
if문을 보면 v1 > v2일 경우 v2를, 그렇지 않을 경우 v1를 조건으로 사용하라고 되어있습니다. 따라서 v1의 값인 0을 조건으로 사용합니다. (조건은 결과가 0이면 false, 나머지는 true)
<<는 왼쪽 시프트 연산자 입니다. 즉, v1 = 0 = 거짓이므로 else로 넘어가고, v3의 값을 왼쪽으로 2비트 이동합니다.
29 = 11101 에서 2비트 이동하면 1110100 = 116 = v3이 됩니다.
코드를 끝까지 읽어야 하는게, v3이 답이 아닌 v2+v3이 답이므로 35 + 116 = 151 이 답입니다.
(문제를 끝까지 안 읽고 답을 적었다가 점수를 잃는 상황이 종종 발생함)
<24년 1회 5번>
class Connection{
private static Connection _inst = null;
private int count = 0;
public static Connection get(){
if(_inst == null){
_inst = new Connection();
return _inst;
}
return _inst;
}
public void count() {count++;}
public int getCount() {return count;}
}
public class Test{
public static void main(String[] args){
Connection conn1 = Connection.get();
conn1.count();
Connection conn2 = Connection.get();
conn2.count();
Connection conn3 = Connection.get();
conn3.count();
conn1.count();
System.out.print(conn1.getCount());
}
}
정답: 4
connection 클래스에 싱글톤 패턴이 적용되었습니다. 즉, 객체변수 _inst가 사용하는 메모리 공간을 객체 변수 conn1~conn3이 공유하고 있습니다. _inst가 null이면 새로운 connection 객체를 생성하고 반환하며, null이 아닌 경우 기존 인스턴스를 반환합니다.
count() 메서드 호출 시 값이 증가하며, 최종적으로 4가 출력됩니다.
<24년 1회 11번>
class Parent {
int x, y;
Parent(int x, int y){
this.x = x;
this.y = y;
}
int getX() {
return x*y;
}
}
class Child extends Parent{
int X;
Child(int x){
super(x+1, x);
this.x = x;
}
int getX(int n){
return super.getX() + n;
}
}
public class Main{
public static void main(String[] args){
Parent parent = new Child(10);
System.out.println(Parent.getX());
}
}
정답: 110
Child 클래스가 Parent 클래스를 상속하며, this.x = x;가 실행되어 부모 클래스의 x를 다시 덮어씌웁니다. getX(int n)에서 부모의 getX() 값에 n을 더해 반환하며, Parent.getX()를 호출하므로 11*10 (main 메서드에선 hetX(int n)을 호출하지 않고 getX()를 호출)
아무 생각 없이 120이라고 적었다가 틀린 문제 😅
<24년 1회 18번>
class firstArea{
int x, y;
public firstArea(int x, int y){
this.x = x;
this.y = y;
}
public void print(){
System.out.println(x+y);
}
}
class secondArea extends firstArea{
int bb = 3;
public secondArea(int i){
super(i, i+1);
}
public void print(){
System.out.println(bb*bb);
}
}
public class Main{
public static void main(String[] args){
firstArea st = new secondArea(10);
st.print();
}
}
정답: 9
마찬가지로 상속의 개념이 잘 잡혀있지 않으면 헷갈릴 수 있는 문제입니다. secondArea 클래스의 생성자를 이용해 firstArea클래스의 객체 변수 st를 선언했으므로, 클래스 형 변환이 발생한 것이며 이 때 자식클래스인 secondArea의 print() 메소드가 수행됩니다.
