14. replaceAll
문제
문자열과 두 개의 문자(from, to)를 입력받아, 문자열에 등장하는 특정 문자(from)가 다른 문자(to)로 바뀐 문자열을 리턴해야 합니다.
입력
인자 1 : str
- String 타입의 문자열
인자 2 : from
- char 타입의 문자
인자 3 : to
- char 타입의 문자
출력
- String 타입을 리턴해야 합니다.
주의사항
- 반복문(for)문을 사용해야 합니다.
입출력 예시
String output = replaceAll("loop", 'o', 'e');
System.out.println(output); // --> "leep"
public class Solution {
public String replaceAll(String str, char from, char to) {
// TODO:
}
}
정답
package com.choongang;
public class N_CharacterAndNumber {
public String characterAndNumber(String word) {
// TODO:
String output = "";
for (int i = 0; i < word.length(); i++) {
output = output + word.charAt(i) + i;
}
return output;
}
}
Test
package com.choongang;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
class N_CharacterAndNumberTest {
N_CharacterAndNumber test = new N_CharacterAndNumber();
@Test
@DisplayName("\"fanta\"을(를) 입력받은 경우, \"f0a1n2t3a4\"을(를) 리턴해야 합니다")
void characterAndNumber() {
assertThat(test.characterAndNumber("fanta")).isEqualTo("f0a1n2t3a4");
}
@Test
@DisplayName("\"lion\"을(를) 입력받은 경우, \"l0i1o2n3\"을(를) 리턴해야 합니다")
void characterAndNumber2() {
assertThat(test.characterAndNumber("lion")).isEqualTo("l0i1o2n3");
}
}
15. computePower
문제
밑(base)과 지수(exponent)를 입력받아 밑의 거듭제곱을 리턴해야 합니다.
입력
인자 1 : base
- int 타입의 밑
인자 2 : exponent
- int 타입의 지수
출력
- int 타입을 리턴해야 합니다.
주의 사항
- 반복문(for)문을 사용해야 합니다.
- Math.pow, 거듭제곱 연산자 사용은 금지됩니다. (거듭제곱은 자바에서 제공하는 Math를 통해 쉽게 구할 수 있습니다.)
입출력 예시
int output = computePower(2, 3);
System.out.println(output); // --> 8
public class Solution {
public int computePower(int base, int exponent) {
// TODO:
}
}
정답
package com.choongang;
public class O_ComputePower {
public int computePower(int base, int exponent) {
// TODO:
int output = 1;
for (int i = 0; i < exponent; i++) {
output *= base;
}
return output;
}
}
Test
package com.choongang;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
class O_ComputePowerTest {
O_ComputePower test = new O_ComputePower();
@Test
@DisplayName("차례대로 -2, 0을(를) 입력받은 경우, 1을(를) 리턴해야 합니다")
void computePower() {
assertThat(test.computePower(-2, 0)).isEqualTo(1);
}
@Test
@DisplayName("차례대로 2, 4을(를) 입력받은 경우, 16을(를) 리턴해야 합니다")
void computePower2() {
assertThat(test.computePower(2, 4)).isEqualTo(16);
}
@Test
@DisplayName("차례대로 -2, 4을(를) 입력받은 경우, 16을(를) 리턴해야 합니다")
void computePower3() {
assertThat(test.computePower(-2, 4)).isEqualTo(16);
}
}
16. getSumOfFactors
문제
수를 입력받아 약수(factor)의 합을 리턴해야 합니다.
입력
인자 1 : num
- int 타입의 수
출력
- int 타입을 리턴해야 합니다.
입출력 예시
int output = getSumOfFactors(8);
System.out.println(output); // --> 15 (1 + 2 + 4 + 8)
output = getSumOfFactors(12);
System.out.println(output); // --> 28 (1 + 2 + 3 + 4 + 6 + 12)
public class Solution {
public int getSumOfFactors(int num) {
// TODO:
}
}
정답
package com.choongang;
public class P_GetSumOfFactors {
public int getSumOfFactors(int num) {
// TODO:
int output = 0;
for (int i = 1; i <= num; i++) {
if (num % i == 0) {
output += i;
}
}
return output;
}
}
package com.choongang;
public class P_GetSumOfFactors {
public int getSumOfFactors(int num) {
// TODO:
int output = 0;
for (int i = 1; i <= num; i++) {
for (int j = i + 1; j <= num; j++) {
if (i * j == num) {
output = output + i + j;
}
if (i * j > num) {
break;
}
}
}
return output;
}
}
Test
package com.choongang;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
class P_GetSumOfFactorsTest {
P_GetSumOfFactors test = new P_GetSumOfFactors();
@Test
@DisplayName("28을(를) 입력받은 경우, 56을(를) 리턴해야 합니다")
void getSumOfFactors() {
assertThat(test.getSumOfFactors(28)).isEqualTo(56);
}
@Test
@DisplayName("496을(를) 입력받은 경우, 992을(를) 리턴해야 합니다")
void getSumOfFactors2() {
assertThat(test.getSumOfFactors(496)).isEqualTo(992);
}
@Test
@DisplayName("12887을(를) 입력받은 경우, 15048을(를) 리턴해야 합니다")
void getSumOfFactors3() {
assertThat(test.getSumOfFactors(12887)).isEqualTo(15048);
}
}
17. isPrime
문제
1 이상의 자연수를 입력받아 소수(prime number)인지 여부를 리턴해야 합니다.
입력
인자 1 : num
- int 타입의 수
출력
- boolean 타입을 리턴해야 합니다.
입출력 예시
boolean output = isPrime(2);
System.out.println(output); // --> true
output = isPrime(6);
System.out.println(output); // --> false
output = isPrime(17);
System.out.println(output); // --> true
힌트
- Math를 활용해 불필요한 연산을 줄일 수 있습니다. (how to find java square root 또는 자바 제곱근)
public class Solution {
public boolean isPrime(int num) {
// TODO:
}
}
정답
package com.choongang;
public class Q_IsPrime {
public boolean isPrime(int num) {
// TODO:
boolean output = true;
if (num <= 1) {
output = false;
}
for (int i = 2; i <= Math.sqrt(num); i++) {
if (num % i == 0) {
output = false;
break;
}
}
return output;
}
}
Test
package com.choongang;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
class Q_IsPrimeTest {
Q_IsPrime test = new Q_IsPrime();
@Test
@DisplayName("1을(를) 입력받은 경우, false를 리턴해야 합니다")
void isPrime() {
assertThat(test.isPrime(1)).isFalse();
}
@Test
@DisplayName("4을(를) 입력받은 경우, false를 리턴해야 합니다")
void isPrime2() {
assertThat(test.isPrime(4)).isFalse();
}
@Test
@DisplayName("97을(를) 입력받은 경우, true를 리턴해야 합니다")
void isPrime3() {
assertThat(test.isPrime(97)).isTrue();
}
@Test
@DisplayName("11587을(를) 입력받은 경우, true를 리턴해야 합니다")
void isPrime4() {
assertThat(test.isPrime(11587)).isTrue();
}
@Test
@DisplayName("12887을(를) 입력받은 경우, false를 리턴해야 합니다")
void isPrime5() {
assertThat(test.isPrime(12887)).isFalse();
}
}
18. listPrimes
문제
2 이상의 자연수를 입력받아 2부터 해당 수까지의 소수(prime number)들을 리턴해야 합니다.
입력
인자 1 : num
- int 타입의 정수 (num >= 2)
출력
- String 타입을 리턴해야 합니다.
- 2-3-5-7의 형식으로 리턴해야 합니다.
주의 사항
- 이중 반복문(double for loop)을 사용해야 합니다.
입출력 예시
String output = listPrimes(2);
System.out.println(output); // --> '2'
output = listPrimes(6);
System.out.println(output); // --> '2-3-5'
output = listPrimes(18);
System.out.println(output); // --> '2-3-5-7-11-13-17'
힌트
- 반복문의 break 문에 대해서 학습합니다. (java loop break)
public class Solution {
public String listPrimes(int num) {
// TODO:
}
}
정답
package com.choongang;
public class R_ListPrimes {
public String listPrimes(int num) {
// TODO:
String output = "2";
boolean isPrime = false;
for (int i = 3; i <= num; i += 2) {
isPrime = true;
int sqrt = (int) Math.sqrt(i);
for (int j = 3; j <= sqrt; j += 2) {
if (i % j == 0) {
isPrime = false;
break;
}
}
if (isPrime) {
output += "-" + i;
}
}
return output;
}
}
Test
package com.choongang;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
class R_ListPrimesTest {
R_ListPrimes test = new R_ListPrimes();
@Test
@DisplayName("3을(를) 입력받은 경우, \"2-3\"를 리턴해야 합니다")
void listPrimes() {
assertThat(test.listPrimes(3)).isEqualTo("2-3");
}
@Test
@DisplayName("4을(를) 입력받은 경우, \"2-3\"를 리턴해야 합니다")
void listPrimes2() {
assertThat(test.listPrimes(4)).isEqualTo("2-3");
}
@Test
@DisplayName("12을(를) 입력받은 경우, \"2-3-5-7-11\"를 리턴해야 합니다")
void listPrimes3() {
assertThat(test.listPrimes(12)).isEqualTo("2-3-5-7-11");
}
@Test
@DisplayName("2을(를) 입력받은 경우, \"2\"를 리턴해야 합니다")
void listPrimes4() {
assertThat(test.listPrimes(2)).isEqualTo("2");
}
@Test
@DisplayName("22을(를) 입력받은 경우, \"2-3-5-7-11-13-17-19\"를 리턴해야 합니다")
void listPrimes5() {
assertThat(test.listPrimes(22)).isEqualTo("2-3-5-7-11-13-17-19");
}
@Test
@DisplayName("46을(를) 입력받은 경우, \"2-3-5-7-11-13-17-19-23-29-31-37-41-43\"를 리턴해야 합니다")
void listPrimes6() {
assertThat(test.listPrimes(46)).isEqualTo("2-3-5-7-11-13-17-19-23-29-31-37-41-43");
}
}
19. makePermutations
문제
문자열을 입력받아 해당 문자열에 등장하는 각 문자(letter)를 가지고 만들 수 있는 길이 2의 문자열들을 리턴해야 합니다.
입력
인자 1 : str
- String 타입의 문자열
출력
- String 타입을 리턴해야 합니다.
- 입력받은 문자열의 각 문자를 0, 1, 2, ..., n이라고 할 경우, 00,01,02,...,nn 형식으로 리턴해야 합니다.
주의 사항
- 이중 반복문(double for loop)을 사용해야 합니다.
- 빈 문자열을 입력받은 경우에는 빈 문자열을 리턴해야 합니다.
입출력 예시
String output = makePermutations("ab");
System.out.println(output); // --> "aa,ab,ba,bb"
output = makePermutations("123");
System.out.println(output); // --> "11,12,13,21,22,23,31,32,33"
output = makePermutations("");
System.out.println(output); // --> ""
힌트
- 문자열은 str.substring()을 활용해 잘라낼 수 있습니다.
String str = "javascript!";
System.out.println(str.substring(0, str.length() - 1)); // "javascript"
public class Solution {
public String makePermutations(String str) {
// TODO:
}
}
정답
package com.choongang;
public class S_MakePermutations {
public String makePermutations(String str) {
// TODO:
String output = "";
if (str.isEmpty()) {
return output;
}
for (int left = 0; left < str.length(); left++) {
for (int right = 0; right < str.length(); right++) {
output = output + str.charAt(left) + str.charAt(right) + ",";
}
}
return output.substring(0, output.length() - 1);
}
}
Test
package com.choongang;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
class S_MakePermutationsTest {
S_MakePermutations test = new S_MakePermutations();
@Test
@DisplayName("빈 문자열을 입력받은 경우, 빈 문자열을 리턴해야 합니다")
void makePermutations() {
assertThat(test.makePermutations("")).isEqualTo("");
}
@Test
@DisplayName("'+'을(를) 입력받은 경우, '++'을(를) 리턴해야 합니다")
void makePermutations2() {
assertThat(test.makePermutations("+")).isEqualTo("++");
}
@Test
@DisplayName("'87'을(를) 입력받은 경우, '88,87,78,77'을(를) 리턴해야 합니다")
void makePermutations3() {
assertThat(test.makePermutations("87")).isEqualTo("88,87,78,77");
}
@Test
@DisplayName("'cat'을(를) 입력받은 경우, 'cc,ca,ct,ac,aa,at,tc,ta,tt'을(를) 리턴해야 합니다")
void makePermutations4() {
assertThat(test.makePermutations("cat")).isEqualTo("cc,ca,ct,ac,aa,at,tc,ta,tt");
}
}
20. hasRepeatedCharacter
문제
문자열을 입력받아 해당 문자열에 중복된 문자(letter)가 존재하는지 여부를 리턴해야 합니다.
입력
인자 1 : str
- String 타입의 문자열
출력
- boolean 타입을 리턴해야 합니다.
주의 사항
- 이중 반복문(double for loop)을 사용해야 합니다.
- 빈 문자열을 입력받은 경우에는 false을 리턴해야 합니다.
입출력 예시
boolean output = hasRepeatedCharacter("abcdefg");
System.out.println(output); // --> false
output = hasRepeatedCharacter("codestates");
System.out.println(output); // --> true
output = hasRepeatedCharacter("");
System.out.println(output); // --> false
public class Solution {
public boolean hasRepeatedCharacter(String str) {
// TODO:
}
}
정답
package com.choongang;
public class T_HasRepeatedCharacter {
public boolean hasRepeatedCharacter(String str) {
// TODO:
boolean output = false;
if (str.isEmpty()) {
return false;
}
for (int left = 0; left < str.length(); left++) {
for (int right = left + 1; right < str.length(); right++) {
if(str.charAt(left) == str.charAt(right)) {
output = true;
return output;
}
}
}
return output;
}
}
Test
package com.choongang;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
class T_HasRepeatedCharacterTest {
T_HasRepeatedCharacter test = new T_HasRepeatedCharacter();
@Test
@DisplayName("빈 문자열을 입력받은 경우, false를 리턴해야 합니다")
void hasRepeatedCharacter() {
assertThat(test.hasRepeatedCharacter("")).isFalse();
}
@Test
@DisplayName("\"abcdefghijklmnopqrstuvwxyz\"을(를) 입력받은 경우, false를 리턴해야 합니다")
void hasRepeatedCharacter2() {
assertThat(test.hasRepeatedCharacter("abcdefghijklmnopqrstuvwxyz")).isFalse();
}
@Test
@DisplayName("\"abcdefghijklmnopqrstuvwxyzz\"을(를) 입력받은 경우, true를 리턴해야 합니다")
void hasRepeatedCharacter3() {
assertThat(test.hasRepeatedCharacter("abcdefghijklmnopqrstuvwxyzz")).isTrue();
}
}
배열(Array)
앞서 변수를 학습하면서, 어떤 값을 저장하기 위해서는 먼저 변수를 선언해야 하며, 변수 선언은 값을 저장하기 위한 메모리 공간을 확보하는 것이라고 배웠습니다.
int num; // 변수 선언
num = 1; // 값 할당
위의 예제에서, 변수 num을 선언하고 num에 1을 할당하였습니다. 익숙하고 쉬운 문법이지만 중요한 사실 하나가 숨어 있습니다. 하나의 변수는 하나의 값만 저장할 수 있다는 것입니다.
num = 1, 2, 3, 4, 5; // 하나의 변수에 여러 데이터를 할당할 수 없습니다.
그렇다면, 많은 값을 저장해야 하는 다음과 같은 상황에서는 부득이하게 많은 수의 변수를 선언해야만 합니다.
- 7월 한 달 동안의 일별 최고 기온을 저장할 때
- 예 : double temperatureOfJuly1; double temperatureOfJuly2; ... double temperatureOfJuly31;
- → 총 31개의 변수를 선언해야 함.
- 7월 한 달 동안의 일별 강수 여부를 저장할 때
- 예 : boolean isRainyJuly1; boolean isRainyJuly2; ... boolean isRainyJuly31;
- → 총 31개의 변수를 선언해야 함.
무언가 비효율적이지 않나요? 각 값을 저장하기 위해 저장할 값의 개수만큼 일일이 변수를 선언하고 있으며, 각 변수의 이름을 다르게 지어주어야 하므로 상당히 번거롭습니다.
이러한 불편함과 번거로움을 줄여줄 수 있는 스마트한 방법이 없을까요? 잠시 저장하고자 하는 값을 자세히 살펴봅시다. 예시에서 언급한 값들은 다음과 같은 공통성을 지닙니다.
- 7월 한 달 동안의 일별 최고 기온을 저장할 때
- 31개의 값은 모두 일별 최고 기온을 나타내는 double 형의 값입니다.
- 7월 한 달 동안의 일별 강수 여부를 저장할 때
- 31개의 값은 모두 일별 강수 여부를 나타내는 boolean 형의 값입니다.
이처럼 각 값들이 같은 타입을 가지는 경우, 배열을 사용하면 여러 개의 변수를 선언하지 않고도 단 하나의 변수만으로 값들을 저장하고 참조할 수 있습니다.
이어지는 콘텐츠에서부터 배열이 무엇인지, 배열을 어떻게 활용할 수 있는지에 대해 학습해 봅시다.
학습목표
- 배열이 무엇인지 이해한다.
- 1차원 배열과 2차원 배열을 이해한다.
- 배열을 선언하고 초기화하는 방법을 이해한다.
- 배열을 탐색하고 값을 사용하는 방법을 이해한다.
배열이란?
앞서 개요에서 언급한 예시를 다시 살펴보겠습니다.
- 7월 한 달 동안의 일별 최고 기온을 저장할 때 → 7월은 총 31일 → 총 31개의 변수가 필요합니다.
double temperatureOfJuly1 = 28.1;
double temperatureOfJuly2 = 30.2;
...
double temperatureOfJuly31 = 32.3;
- 7월 한 달 동안의 일별 강수 여부를 저장할 때 → 7월은 총 31일 → 총 31개의 변수가 필요합니다.
boolean isRainyJuly1 = true;
boolean isRainyJuly2 = false;
...
boolean isRainyJuly31 = false;
위와 같은 상황일 때, 배열 없이 단순히 변수로만 값을 저장하려면 두 상황 각각 31개의 변수를 선언해야 합니다. 그러나 배열을 사용하면 각 상황마다 단 하나의 변수만으로 데이터를 다룰 수 있습니다.
배열이란, 동일한 타입의 값들을 하나의 묶음으로 묶은 자료 구조를 의미합니다. 즉, 각 값들이 같은 의미를 지니면서 서로 연관성이 있을 때, 이들을 하나의 덩어리로 묶을 수 있으며, 이렇게 묶인 값들의 집합을 배열이라고 합니다.
그림을 통해 조금 더 자세하게 이해해 봅시다. 그림으로 배열을 설명하기에 앞서, 메모리의 구조를 간단하게 짚을 필요가 있습니다.
아래는 여러분이 RAM으로 알고 있는 메모리를 형상화한 그림입니다. 메모리는 아래와 같이 여러 메모리셀들로 이루어져 있으며, 각 메모리셀은 값을 저장할 수 있는 1바이트의 메모리 공간을 가지고 있습니다.
이 메모리 공간을 아래 그림에서는 빈칸으로 표현해 두었습니다. 또한 각 메모리 셀마다 0x001a3d41과 같이 16진수로 이루어진 메모리 주소가 지정되어 있으며, 메모리 주소는 오름차순으로 매겨져 있습니다.
그림을 살펴보면 여러분이 16진수에 대해 알지 못하더라도, 오른쪽으로 갈수록 메모리셀의 일의 자리 숫자가 1씩 증가하는 것을 확인할 수 있습니다.
여러분은 16진수에 대해서 자세히 알 필요가 없습니다. 여기에서 여러분이 메모리 구조를 간단하게 훑어보는 이유는 지금부터 배울 배열에 대해 조금 더 명확하게 학습하기 위함이지, 컴퓨터 공학에서의 메모리 구조 그 자체를 배우기 위함이 아닙니다. 따라서, 여기에서는 “메모리는 아래의 그림처럼 간략화해서 표현할 수 있으며, 각 메모리 셀들의 주소가 오름차순으로 이루어져 있구나” 정도로 이해해 주시면 충분합니다.
자, 이제 변수를 개별적으로 선언하여 7월 한 달 동안의 일별 최고 기온을 저장하는 경우를 살펴봅시다. 이 경우, 각 변수는 개별적으로 선언된 변수이므로 메모리 공간 상에 흩어져서 개별적으로 존재하게 됩니다.
double temperatureOfJuly1 = 28.1;
double temperatureOfJuly2 = 30.2;
...
double temperatureOfJuly31 = 32.3;
참고로, 위 그림에서 각 값이 차지하는 공간이 0x001a3d41 ~ 0x001a3d48과 같이 8바이트 단위인 이유는 각 값이 크기가 8바이트인 double형이기 때문입니다.
그러나 배열을 사용하여 값을 저장하는 경우, 아래와 같이 메모리 공간 상에 연속적으로 값들이 모여서 저장됩니다.
배열의 선언과 초기화 방법은 이어지는 콘텐츠에서 학습할 예정이니, 여기에서는 가볍게 훑어보고 넘어가주시기 바랍니다. 지금은 딱 아래와 같이만 이해해 주시면 충분합니다.
”배열을 선언하고 초기화하는 방법은 아직 모르겠지만, 어쨌든 배열에 값을 저장하면 아래 그림과 같이 값들이 서로 모여서 저장되는구나!” ”자세히는 모르겠지만 중괄호({})를 통해 값들을 묶을 수 있구나!”
double[] temperatureOfJuly = { 27.4, 30.1, ..., 31.8 };
위 그림을 통해 알 수 있듯, 배열을 통해 값들을 묶어서 저장한다는 것은 메모리 공간 상에 물리적으로 값들을 모아서 저장하는 것을 의미합니다.
배열과 관련하여 중요한 개념을 알려드리겠습니다. 위 그림에서 배열이 가진 각 값들을 배열의 **요소(element)**라고 합니다. 그리고, 배열의 각 요소는 0에서부터 시작하는 번호를 부여받는데, 이처럼 배열의 각 요소가 부여받는 순번을 **인덱스(index)**라고 합니다. 예를 들어, 배열의 맨 첫 번째 요소의 인덱스는 0이며, 두 번째 인덱스는 1, 마지막 요소인 31번째 요소의 인덱스는 30이 됩니다.
이제 여러분은 배열이 무엇인지에 대한 개념적인 학습을 마쳤습니다. 다시 한번 언급하지만 배열을 선언하고 초기화하는 방법, 그리고 배열 요소의 값을 참조하는 방법에 대해서는 다음 콘텐츠에서부터 다룰 예정입니다. 이 콘텐츠에서는 개념적인 부분에 한해서만 이해해 주시기 바랍니다.
배열의 차원이란?
배열을 사용할 때, 1차원 배열과 2차원 배열을 흔히 사용합니다. 필요에 따라서는 3차원 배열과 4차원 배열도 만들어 사용할 수 있지만, 사용 빈도는 1차원 배열과 2차원 배열에 비해 현저히 드뭅니다.
배열과 관련하여 언급되는 ‘차원’이라는 것은 배열이 중첩된 정도를 의미합니다. 즉, 배열이 중첩되었다 함은, 배열의 요소가 또 다른 배열인 경우를 의미합니다. 자주 사용하는 1차원 배열과 2차원 배열에 대해서만 설명하겠습니다. 참고로, 2차원 이상의 배열을 다차원 배열이라고 합니다.
- 1차원 배열 : 배열이 중첩이 없는 경우 = 배열의 요소가 배열이 아닌 경우
- 예 : { 1, 2, 3, 4 }
- 배열의 각 요소는 1, 2, 3, 4로 모두 정수형의 값입니다.
- 예 : { 1, 2, 3, 4 }
- 2차원 배열 : 배열이 한번 중첩된 경우 = 배열의 요소가 배열인 경우
- 예 : { { 1, 2, 3, 4 }, { 5, 6, 7, 8 } }
- 배열의 각 요소로 배열이 들어가 있습니다.
- 예 : { { 1, 2, 3, 4 }, { 5, 6, 7, 8 } }
자, 이제 본격적으로 배열을 학습하기 위해 필요한 개념들을 모두 학습하였습니다. 이제 다음 콘텐츠에서부터는 지금까지 학습한 내용들을 기반으로 배열을 어떻게 사용할 수 있는지에 대해 배워봅시다.
1차원 배열
배열을 선언하고 생성하는 방법에는 여러 가지 방법이 존재합니다. 하지만 모든 방법을 여러분들이 다 알 필요는 없습니다. 이 콘텐츠에서는 여러분들이 학습하고 사용하기에 간편한 방법만을 골라서 정리하였습니다.
1차원 배열의 선언과 초기화
1차원 배열은 가장 일반적인 배열의 형태로, 배열의 요소가 배열이 아닌 배열을 의미합니다. 1차원 배열을 선언할 때에는 다음과 같이 타입 뒤에 대괄호를 붙여서 선언하고 초기화할 수 있습니다.
double[] temperatureOfJuly;
temperatureOfJuly = new double[31];
위의 예제가 실행되면 내부적으로 아래와 같은 동작이 이루어집니다.
- double[] temperatureOfJuly;
- 배열을 가리킬 참조 변수 temperatureOfJuly를 선언합니다.
- 참조 변수에 대한 설명은 아래에서 하도록 하겠습니다.
2. new double[31];
- 총 31개의 double형 값을 저장할 수 있는 배열이 생성됩니다.
- 이때, 배열의 모든 요소는 double형의 기본값인 0.0으로 초기화되어 있습니다.
3. temperatureOfJuly = new double[31];
- 대입 연산자(=)에 의해 생성된 배열 첫 번째 요소의 주소값이 참조 변수 temperatureOfJuly에 할당됩니다.
- 이제 참조 변수 temperatureOfJuly는 배열의 맨 첫 번째 요소를 가리키게 됩니다.
왜 temperatureOfJuly는 참조 변수여야만 할까요?
자바에서 배열은 참조 타입에 해당합니다. 따라서 double[]이라는 배열 선언 문법으로 선언한 temperatureOfJuly는 선언 이후에 생성될 배열의 주소값을 담을 참조 변수가 됩니다.
잠시 [타입] 콘텐츠에서 학습했던 내용을 복습해 봅시다. 자바의 타입은 기본 타입과 참조 타입으로 나뉜다고 했습니다.
- 기본 타입의 값을 변수에 할당하면 해당 변수에는 실제 값이 저장됩니다.
- 참조 타입의 값을 변수에 할당하면 해당 변수에는 주소값이 저장됩니다.
변수를 선언한다는 것은 어떤 값을 저장할 메모리 공간을 확보하고, 해당 메모리 공간에 이름을 붙이는 것을 의미합니다.
int형, double형과 같은 기본 타입의 경우, 기본 타입의 값을 저장할 변수를 선언하는 시점에 얼마만큼의 메모리 공간을 확보해야 하는지 컴퓨터가 알 수 있습니다. 변수 이름 앞에 타입이 붙어 있으며, 각 타입 별로 크기가 정해져 있기 때문입니다.
double temperature;
// 컴퓨터 : 'double형이니 8byte의 메모리를 확보하면 되겠군.'
그러나, 참조 타입의 경우는 다릅니다.
double[] temperatureOfJuly;와 같이 배열을 선언하는 시점에 배열이 몇 개의 요소를 가질지 컴퓨터는 알 수 없습니다. 따라서 배열을 선언하면, 이후에 생성될 배열의 주소값을 담을 메모리 공간만이 확보됩니다. 이후 배열이 생성되고 난 다음에 해당 배열의 시작 주소값이 참조 변수에 할당됩니다.
double[] temperatureOfJuly;
// 컴퓨터 : '타입에 []가 붙었으니 배열 참조 변수군. 배열의 요소가 몇 개일지 모르니 어딘가에 배열을
// 먼저 생성한 다음, 생성된 배열의 시작 주소를 temperatureOfJuly에 메모해두자'
참고로, 선언과 초기화는 아래와 같이 하나의 문장으로 작성할 수도 있습니다. 결과는 위의 예제 코드와 같습니다.
double[] temperatureOfJuly = new double[31];
여기까지 배열을 선언하고 초기화하는 방법을 알아보았습니다.
그러나, 위의 방법으로 생성한 배열의 요소는 모두 double형의 기본값인 0.0으로 초기화되어 있는 상태입니다. 27.4, 30.1와 같은 실제 값을 넣어서 초기화하려면 어떻게 해야 할까요? 아래와 같이 하면 됩니다.
double[] temperatureOfJuly = new double[] { 27.4, 30.1, 31.1, 32.4, ..., 31.8 };
// 선언과 초기화를 하나의 문장으로 할 때에 한해 new double[]을 생략할 수 있습니다.
double[] temperatureOfJuly = { 27.4, 30.1, 31.1, 32.4, ..., 31.8 };
2차원 배열이란?
2차원 배열은 배열의 각 요소가 또 다른 배열인 구조일 뿐, 1차원 배열과 크게 다른 점은 없습니다.
1차원 배열에서 이해한 내용을 토대로 2차원 배열을 이해해 보시기 바랍니다. 여러분이 스스로 예제를 분석해 보는 것도 중요하기에 1차원 배열에서 했던 설명을 중복하지 않겠습니다. 천천히 예제 코드를 보며 2차원 배열을 어떻게 사용하는지 학습해 봅시다.
2차원 배열을 설명하기 위해 다음의 상황을 가정하겠습니다.
프로그래밍을 공부하면서 여러분은 급격하게 몸무게가 늘기 시작했습니다. 특단의 다이어트 계획을 세운 여러분은 앞으로 섭취하는 하루 세끼의 열량(kcal)을 7월 한 달 동안 측정하고 기록해서 2차원 배열에 저장하여 평균, 총합 등의 통계를 내보고자 합니다.
2차원 배열의 선언과 초기화
2차원 배열을 선언하고 초기화하는 방법은 일차원 배열과 유사합니다. 아래 예제 코드를 보고, 1차원 배열의 선언 및 초기화와 어떤 차이가 있는지 스스로 확인해 보세요.
int[][] kcal;
kcal = new int[31][3];
위 코드는 1차원 배열에서와 마찬가지로 한 줄로 줄여서 작성할 수 있습니다.
int[][] kcal = new int[31][3];
예제 코드가 실행되면 다음과 같은 2차원 배열이 만들어집니다. 이 2차원 배열의 내부 배열은 int형의 기본값인 0을 3개씩 저장하고 있으며, 외부 배열은 내부 배열({ 0, 0, 0 }) 31개를 저장하고 있습니다.
엄밀히 말하면, 내부 배열은 3개의 0을 요소로 가지지만, 외부 배열의 각 요소는 내부 배열의 주소값을 저장하고 있습니다.
{
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
...
{ 0, 0, 0 }
}
값을 넣어 초기화를 하는 경우, 다음과 같이 코드를 작성하면 됩니다. 1차원 배열에서와 맥락은 같으니 자세한 설명은 생략하겠습니다.
int[][] kcal = new int[][] {
{ 1982, 2098, 2130 },
{ 2242, 2431, 2198 },
{ 2365, 1997, 1932 },
...
{ 2278, 2391, 2006 }
};
// 선언과 초기화를 하나의 문장으로 할 때에 한해 new int[][]를 생략할 수 있습니다.
int[][] kcal = {
{ 1982, 2098, 2130 },
{ 2242, 2431, 2198 },
{ 2365, 1997, 1932 },
...
{ 2278, 2391, 2006 }
};
여기까지 2차원 배열에 대해 살펴보았습니다. 2차원 배열에 대해 충분히 이해하셨다면 아래의 예제를 직접 풀어보세요.
- 1차원 배열을 설명할 때 제시했던 그림처럼, 이 콘텐츠에서 제시한 열량 기록 배열(kcal)이 메모리 상에 어떻게 생성되어 있을지 직접 그려보세요.
- 힌트 : 아래 두 코드를 실행해 보고, 차이점을 분석해 보세요.
- System.out.println(Arrays.toString(kcal));
- System.out.println(Arrays.toString(kcal[0]));
- 힌트 : 아래 두 코드를 실행해 보고, 차이점을 분석해 보세요.
가변 배열
2차원 이상의 다차원 배열에서는 1차원보다는 자유로운 형태로 배열을 만들 수 있습니다. 즉, 배열이 2차원 이상일 때, 마지막 차수에 해당하는 배열의 길이를 고정하지 않아도 되며, 이러한 배열을 가변 배열이라고 합니다.
가변 배열은 다음과 같이 선언하고 초기화할 수 있습니다.
int[][] ages = new int[5][];
위 예제의 new int[5][]에서, 외부 배열은 크기를 5로 지정했으나, 마지막 차수에 해당하는 내부 배열에는 크기를 지정하지 않았습니다. 이처럼 마지막 차수에 해당하는 배열의 크기를 지정하지 않으면 가변 배열이 생성됩니다.
이때 생성된 것은 내부 배열의 크기를 자유롭게 지정할 수 있는 외부 배열입니다. 즉, 외부 배열만 생성된 상태입니다.
int[][] ages = new int[5][];
System.out.println("Arrays.toString(ages) = " + Arrays.toString(ages));
// 결과
// Arrays.toString(ages) = [null, null, null, null, null]
내부 배열을 생성하려면 new int[]를 사용하여 외부 배열의 각 요소에 할당해 주면 됩니다.
int[][] ages = new int[5][];
ages[0] = new int[5];
ages[1] = new int[6];
ages[2] = new int[7];
ages[3] = new int[8];
ages[4] = new int[9];
System.out.println("Arrays.toString(ages[0]) = " + Arrays.toString(ages[0]));
System.out.println("Arrays.toString(ages[1]) = " + Arrays.toString(ages[1]));
System.out.println("Arrays.toString(ages[2]) = " + Arrays.toString(ages[2]));
System.out.println("Arrays.toString(ages[3]) = " + Arrays.toString(ages[3]));
System.out.println("Arrays.toString(ages[4]) = " + Arrays.toString(ages[4]));
// 결과
// Arrays.toString(ages[0]) = [0, 0, 0, 0, 0]
// Arrays.toString(ages[1]) = [0, 0, 0, 0, 0, 0]
// Arrays.toString(ages[2]) = [0, 0, 0, 0, 0, 0, 0]
// Arrays.toString(ages[3]) = [0, 0, 0, 0, 0, 0, 0, 0]
// Arrays.toString(ages[4]) = [0, 0, 0, 0, 0, 0, 0, 0, 0]
가변 배열도 일반적인 배열과 같이 생성과 동시에 초기화할 수 있습니다.
int[][] ages = {
{ 30, 32, 39, 59, 23 },
{ 31, 41, 52, 56, 72, 13 },
{ 45, 32, 84, 23, 13, 42, 55 },
{ 23, 41, 62, 64, 23, 51, 67, 98 },
{ 13, 14, 17, 84, 52, 37, 68, 66, 33 }
};
System.out.println("Arrays.toString(ages[0]) = " + Arrays.toString(ages[0]));
System.out.println("Arrays.toString(ages[1]) = " + Arrays.toString(ages[1]));
System.out.println("Arrays.toString(ages[2]) = " + Arrays.toString(ages[2]));
System.out.println("Arrays.toString(ages[3]) = " + Arrays.toString(ages[3]));
System.out.println("Arrays.toString(ages[4]) = " + Arrays.toString(ages[4]));
// 결과
// Arrays.toString(ages[0]) = [30, 32, 39, 59, 23]
// Arrays.toString(ages[1]) = [31, 41, 52, 56, 72, 13]
// Arrays.toString(ages[2]) = [45, 32, 84, 23, 13, 42, 55]
// Arrays.toString(ages[3]) = [23, 41, 62, 64, 23, 51, 67, 98]
// Arrays.toString(ages[4]) = [13, 14, 17, 84, 52, 37, 68, 66, 33]
배열 탐색
앞서 배운 반복문을 활용하여 배열을 탐색할 수 있으며, 기본적으로 인덱스와 배열의 크기(length)를 활용하여 탐색한다는 점에서 문자열 탐색과 비슷합니다. 즉, 여러분이 앞서 연습 문제에서 문자열을 반복문으로 순회하고 탐색했던 것과 비슷한 방법으로 배열을 순회할 수 있습니다.
반복문을 통한 배열 탐색
배열의 각 요소들의 총합을 구하는 예제를 통해 어떻게 반복문을 사용하여 배열을 탐색할 수 있는지 살펴보겠습니다. 예제에 사용될 배열은 아래와 같습니다.
int[] scores = { 100, 90, 85, 95, 100 };
일반적인 for문으로 배열을 순회하여 총합을 구하는 코드는 다음과 같습니다.
int[] scores = { 100, 90, 85, 95, 100 };
int sum = 0;
for (int i = 0; i < scores.length; i++) {
sum += scores[i];
}
System.out.println(sum); // 470
while문을 통한 배열 순회는 다음과 같이 할 수 있습니다.
int[] scores = { 100, 90, 85, 95, 100 };
int sum = 0;
int i = 0;
while (i < scores.length) {
sum += scores[i++];
}
System.out.println(sum); // 470
향상된 for문(Enhanced for문)으로도 배열의 각 요소에 접근할 수 있습니다.
int[] scores = { 100, 90, 85, 95, 100 };
int sum = 0;
for (int score: scores) {
sum += score;
}
System.out.println(sum); // 470
향상된 for문을 사용할 때 주의해야 할 사항이 있습니다. 향상된 for문을 통해 배열을 순회하는 것은 배열의 값을 읽어오는 것만 가능합니다. 즉, 향상된 for문으로 배열을 순회하면서 배열의 값을 수정할 수는 없습니다.
int[] scores = { 100, 90, 85, 95, 100 };
// 일반적인 for문 및 while문을 사용하면 배열 요소의 값을 바꿀 수 있습니다.
for (int i = 0; i < scores.length; i++) {
scores[i] = 0;
}
System.out.println("for문 사용 : " + Arrays.toString(scores));
int j = 0;
while (j < scores.length) {
scores[j++] = 1;
}
System.out.println("while문 사용 : " + Arrays.toString(scores));
// 향상된 for문을 사용하면 배열 요소의 값을 바꿀 수 없습니다.
for (int score: scores) {
score = 2;
}
System.out.println("향상된 for문 사용 : " + Arrays.toString(scores));
/*
실행 결과
for문 사용 : [0, 0, 0, 0, 0]
while문 사용 : [1, 1, 1, 1, 1]
향상된 for문 사용 : [1, 1, 1, 1, 1]
*/
1. getFirstElement
문제
배열을 입력받아 배열의 첫번째 요소를 리턴해야 합니다.
입력
인자 1 : arr
- int타입의 요소를 갖는 배열
출력
- 배열의 요소를 리턴해야 합니다.
주의 사항
- 빈 배열을 입력받은 경우, -1를 리턴해야 합니다.
입출력 예시
int output = getFirstElement(new int[]{1, 2, 3, 4, 5});
System.out.println(output); // --> -1
public class Solution {
public int getFirstElement(int[] arr) {
// TODO:
}
}
정답
package com.choongang;
public class A_getFirstElement {
public int getFirstElement(int[] arr) {
// TODO:
int output;
if (arr.length == 0) {
return -1;
}
output = arr[0];
return output;
}
}
Test
package com.choongang;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
class A_getFirstElementTest {
A_getFirstElement test = new A_getFirstElement();
@Test
@DisplayName("[5, 4, 1, 2, 6]을(를) 입력받은 경우, 5을(를) 리턴해야 합니다")
void getFirstElement() {
assertThat(test.getFirstElement(new int[]{5, 4, 1, 2, 6})).isEqualTo(5);
}
@Test
@DisplayName("빈 배열을 입력받은 경우, -1을(를) 리턴해야 합니다")
void getFirstElement2() {
assertThat(test.getFirstElement(new int[]{})).isEqualTo(-1);
}
@Test
@DisplayName("[1, 3, 5]을(를) 입력받은 경우, 1을(를) 리턴해야 합니다")
void getFirstElement3() {
assertThat(test.getFirstElement(new int[]{1, 3, 5})).isEqualTo(1);
}
}
2. getLastElement
문제
배열를 입력받아 배열의 마지막 요소를 리턴해야 합니다.
입력
인자 1 : arr
- int타입의 요소를 갖는 배열
출력
- 배열의 요소를 리턴해야 합니다.
주의 사항
- 빈 배열을 입력받은 경우, -1를 리턴해야 합니다.
입출력 예시
int output = getLastElement(new int[]{1, 2, 3, 4});
System.out.println(output); // --> 4
public class Solution {
public int getLastElement(int[] arr) {
// TODO:
}
}
정답
package com.choongang;
public class B_GetLastElement {
public int getLastElement(int[] arr) {
// TODO:
int output = -1;
if (arr.length != 0) {
output = arr[arr.length - 1];
}
return output;
}
}
Test
package com.choongang;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
class B_GetLastElementTest {
B_GetLastElement test = new B_GetLastElement();
@Test
@DisplayName("[5, 4, 1, 2, 6]을(를) 입력받은 경우, 6을(를) 리턴해야 합니다")
void getLastElement() {
int[] arr = new int[]{5, 4, 1, 2, 6};
assertThat(test.getLastElement(arr)).isEqualTo(6);
}
@Test
@DisplayName("빈 배열을 입력받은 경우, -1을(를) 리턴해야 합니다")
void getLastElement2() {
int[] arr = new int[]{};
assertThat(test.getLastElement(arr)).isEqualTo(-1);
}
@Test
@DisplayName("[1, 3, 5]을(를) 입력받은 경우, 5을(를) 리턴해야 합니다")
void getLastElement3() {
int[] arr = new int[]{1, 3, 5};
assertThat(test.getLastElement(arr)).isEqualTo(5);
}
}
3. getNthElement
문제
배열과 수를 입력받아 수가 인덱스로 가리키는 배열의 요소를 리턴해야 합니다.
입력
인자 1 : arr
- int타입의 요소를 갖는 배열
인자 2 : index
- int 타입의 index (0 이상의 정수)
출력
- 배열의 요소를 리턴해야 합니다.
주의 사항
- 빈 배열을 입력받은 경우, -1를 리턴해야 합니다.
- 배열의 길이를 벗어나는 수를 입력받은 경우, '-2'를 리턴해야 합니다.
입출력 예시
int output = getNthElement(new int[]{1, 3, 5}, 1);
System.out.println(output); // --> 3
output = getNthElement(new int[]{1, 3, 5}, 3);
System.out.println(output); // --> '-2'
public class Solution {
public int getNthElement(int[] arr, int index) {
// TODO:
}
}
정답
package com.choongang;
public class C_GetNthElement {
public int getNthElement(int[] arr, int index) {
// TODO:
/**
* 1. 빈 배열일 경우 -1 반환
* 2. index가 배열의 크기를 벗어날 경우에는 -2 반환
* 3. 이외의 경우에는 arr[index] 반환
*/
int output;
if (arr.length == 0) {
return -1;
}
if (index > arr.length - 1) {
return -2;
}
output = arr[index];
return output;
}
}
Test
package com.choongang;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
class C_GetNthElementTest {
C_GetNthElement test = new C_GetNthElement();
@Test
@DisplayName("차례대로 [1, 3, 5, 7], 2을(를) 입력받은 경우, '5'을(를) 리턴해야 합니다")
void getNthElement() {
int[] arr = new int[]{1, 3, 5, 7};
assertThat(test.getNthElement(arr, 2)).isEqualTo(5);
}
@Test
@DisplayName("차례대로 [1, 3, 5, 7], 4을(를) 입력받은 경우, '-2'을(를) 리턴해야 합니다")
void getNthElement2() {
int[] arr = new int[]{1, 3, 5, 7};
assertThat(test.getNthElement(arr, 4)).isEqualTo(-2);
}
@Test
@DisplayName("차례대로 [1, 3, 5], 1을(를) 입력받은 경우, 3을(를) 리턴해야 합니다")
void getNthElement3() {
int[] arr = new int[]{1, 3, 5};
assertThat(test.getNthElement(arr, 1)).isEqualTo(3);
}
@Test
@DisplayName("빈 배열을 입력받은 경우 -1을(를) 리턴해야 합니다")
void getNthElement4() {
int[] arr = new int[]{};
assertThat(test.getNthElement(arr, 0)).isEqualTo(-1);
}
}
4. computeSumOfAllElements
문제
배열을 입력받아 배열의 모든 요소의 합을 리턴해야 합니다.
입력
인자 1 : arr
- int 타입을 요소로 갖는 배열
출력
- int 타입을 리턴해야 합니다.
주의 사항
- 입력받은 배열이 빈 배열인 경우, 0을 리턴해야 합니다.
int output = computeSumOfAllElements(new int[]{1, 2, 3});
System.out.println(output); // --> 6
public class Solution {
public int computeSumOfAllElements(int[] arr) {
// TODO:
}
}
정답
package com.choongang;
public class D_ComputeSumOfAllElements {
public int computeSumOfAllElements(int[] arr) {
// TODO:
int output = 0;
for (int i = 0; i < arr.length; i++) {
output += arr[i];
}
return output;
}
}
Test
package com.choongang;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
class D_ComputeSumOfAllElementsTest {
D_ComputeSumOfAllElements test = new D_ComputeSumOfAllElements();
@Test
@DisplayName("[1020, 3040, 6272]을(를) 입력받은 경우, 10332을(를) 리턴해야 합니다")
void computeSumOfAllElements2() {
int[] arr = new int[]{1020, 3040, 6272};
assertThat(test.computeSumOfAllElements(arr)).isEqualTo(10332);
}
@Test
@DisplayName("[0, -1, -2, -3]을(를) 입력받은 경우, -6을(를) 리턴해야 합니다")
void computeSumOfAllElements3() {
int[] arr = new int[]{0, -1, -2, -3};
assertThat(test.computeSumOfAllElements(arr)).isEqualTo(-6);
}
@Test
@DisplayName("[1, 2, 4]을(를) 입력받은 경우, 7을(를) 리턴해야 합니다")
void computeSumOfAllElements4() {
int[] arr = new int[]{1, 2, 4};
assertThat(test.computeSumOfAllElements(arr)).isEqualTo(7);
}
@Test
@DisplayName("[0, 0, 0, 0, 0, 0, 0]을(를) 입력받은 경우, 0을(를) 리턴해야 합니다")
void computeSumOfAllElements5() {
int[] arr = new int[]{0, 0, 0, 0, 0, 0, 0};
assertThat(test.computeSumOfAllElements(arr)).isEqualTo(0);
}
@Test
@DisplayName("빈 배열을 입력받은 경우, 0을(를) 리턴해야 합니다")
void computeSumOfAllElements() {
int[] arr = new int[]{};
assertThat(test.computeSumOfAllElements(arr)).isEqualTo(0);
}
}
5. getAllWords
문제
문자열을 입력받아 문자열을 구성하는 각 단어를 요소로 갖는 배열을 리턴해야 합니다.
입력
인자 1 : str
- String 타입의 공백이 있는 문자열
출력
- String 타입을 요소로 가지는 배열을 리턴해야 합니다.
주의 사항
- 반복문(for, while) 사용은 금지됩니다.
- 단어는 공백 한 칸으로 구분합니다.
- 연속된 공백은 없다고 가정합니다.
입출력 예시
String[] output = getAllWords("Radagast the Brown");
System.out.println(output); // --> ["Radagast", "the", "Brown"]
힌트
- 문자열은 str.split()를 사용하여 배열로 나누어 저장할 수 있습니다.
정답
package com.choongang;
public class E_GetAllWords {
public String[] getAllWords(String str) {
// TODO:
String[] output = str.split(" ");
if (str.isEmpty()) {
return new String[0];
}
return output;
}
}
Test
package com.choongang;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
class E_GetAllWordsTest {
E_GetAllWords test = new E_GetAllWords();
@Test
@DisplayName("\"Something like this here\"을(를) 입력받은 경우, [\"Something\", \"like\", \"this\", \"here\"]을(를) 리턴해야 합니다")
void getAllWords() {
String str = "Something like this here";
String[] input = test.getAllWords(str);
String[] arr = new String[]{"Something", "like", "this", "here"};
assertArrayEquals(input, arr);
}
@Test
@DisplayName("\"code spring java\"을(를) 입력받은 경우, [\"code\", \"spring\", \"java\"]을(를) 리턴해야 합니다")
void getAllWords2() {
String str = "code spring java";
String[] input = test.getAllWords(str);
String[] arr = new String[]{"code", "spring", "java"};
assertArrayEquals(input, arr);
}
@Test
@DisplayName("빈 문자열을 입력받은 경우, 빈 배열을 리턴해야 합니다")
void getAllWords3() {
String str = "";
String[] input = test.getAllWords(str);
String[] arr = new String[]{};
assertArrayEquals(input, arr);
}
}
6. getAllLetters
문제
문자열을 입력받아 문자열을 구성하는 각 문자를 요소로 갖는 배열을 리턴해야 합니다.
입력
인자 1 : str
- String 타입의 공백이 없는 문자열
출력
- char 타입의 요소를 가지는 배열을 리턴해야 합니다.
주의 사항
- str.split 사용은 금지됩니다.
- 빈 문자열을 입력받은 경우, 빈 배열을 리턴해야 합니다.
입출력 예시
char[] output = getAllLetters("Radagast");
System.out.println(output); // --> ['R', 'a', 'd', 'a', 'g', 'a', 's', 't']
public class Solution {
public char[] getAllLetters(String str) {
// TODO:
}
}
정답
package com.choongang;
public class F_GetAllLetters {
public char[] getAllLetters(String str) {
// TODO:
char[] output = new char[str.length()];
if (str.length() == 0) {
return output;
}
for (int i = 0; i < str.length(); i++) {
output[i] = str.charAt(i);
}
return output;
}
}
Test
package com.choongang;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
class F_GetAllLettersTest {
F_GetAllLetters test = new F_GetAllLetters();
@Test
@DisplayName("\"JavaSpring\"을(를) 입력받은 경우, ['J','a','v','a','S','p','r','i','n','g']을(를) 리턴해야 합니다")
void getAllLetters() {
String str = "JavaSpring";
char[] input = test.getAllLetters(str);
char[] arr = new char[]{'J','a','v','a','S','p','r','i','n','g'};
assertArrayEquals(input, arr);
}
@Test
@DisplayName("\"true\"을(를) 입력받은 경우, ['t', 'r', 'u', 'e']을(를) 리턴해야 합니다")
void getAllLetters2() {
String str = "true";
char[] input = test.getAllLetters(str);
char[] arr = new char[]{'t', 'r', 'u', 'e'};
assertArrayEquals(input, arr);
}
@Test
@DisplayName("\"Eowin\"을(를) 입력받은 경우, ['E', 'o', 'w', 'i', 'n']을(를) 리턴해야 합니다")
void getAllLetters3() {
String str = "Eowin";
char[] input = test.getAllLetters(str);
char[] arr = new char[]{'E', 'o', 'w', 'i', 'n'};
assertArrayEquals(input, arr);
}
@Test
@DisplayName("빈 문자열이 주어졌을 때 빈 배열을 리턴해야 합니다")
void getAllLetters4() {
String str = "";
char[] input = test.getAllLetters(str);
char[] arr = new char[]{};
assertArrayEquals(input, arr);
}
}
7. getLargestElement
문제
배열을 입력받아 가장 큰 요소를 리턴해야 합니다.
입력
인자 1 : arr
- int 타입의 정수로 구성된 배열
출력
- int 타입을 리턴해야 합니다.
입출력 예시
int output = getLargestElement(new int[]{1, 4, 3});
System.out.println(output); // --> 4
output = getLargestElement(new int[]{-4, -2, -9});
System.out.println(output); // --> -2
public class Solution {
public int getLargestElement(int[] arr) {
// TODO:
}
}
정답
package com.choongang;
public class G_GetLargestElement {
public int getLargestElement(int[] arr) {
// TODO:
int maxNumber = Integer.MIN_VALUE;
for (int i = 0; i < arr.length; i++) {
if (maxNumber < arr[i]) {
maxNumber = arr[i];
}
}
return maxNumber;
}
}
Test
package com.choongang;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
class G_GetLargestElementTest {
G_GetLargestElement test = new G_GetLargestElement();
@Test
@DisplayName("[2, 5, 4, 9, 8]을(를) 입력받은 경우, 9을(를) 리턴해야 합니다")
void getLargestElement() {
int[] arr = new int[]{2, 5, 4, 9, };
assertThat(test.getLargestElement(arr)).isEqualTo(9);
}
@Test
@DisplayName("[-1, 2, -5]을(를) 입력받은 경우, 2을(를) 리턴해야 합니다")
void getLargestElement2() {
int[] arr = new int[]{-1, 2, -5};
assertThat(test.getLargestElement(arr)).isEqualTo(2);
}
@Test
@DisplayName("[1, 2, 3, 4]을(를) 입력받은 경우, 4을(를) 리턴해야 합니다")
void getLargestElement3() {
int[] arr = new int[]{1, 2, 3, 4};
assertThat(test.getLargestElement(arr)).isEqualTo(4);
}
@Test
@DisplayName("[-7, -2, -9, -1]을(를) 입력받은 경우, -1을(를) 리턴해야 합니다")
void getLargestElement4() {
int[] arr = new int[]{-7, -2, -9, -1};
assertThat(test.getLargestElement(arr)).isEqualTo(-1);
}
}
8. getLongestWord
문제
문자열을 입력받아 문자열에서 가장 긴 단어를 리턴해야 합니다.
입력
인자 1 : str
- String 타입의 공백이 있는 알파벳 문자열
출력
- String 타입을 리턴해야 합니다.
주의 사항
- 단어는 공백 한 칸으로 구분합니다.
- 가장 긴 단어가 2개 이상이면 첫번째로 등장하는 단어를 리턴해야 합니다.
입출력 예시
String output = getLongestWord("I love spring");
System.out.println(output); // --> "spring"
output = getLongestWord("Teamwork skills will take you anywhere");
System.out.println(output); // --> "Teamwork"
public class Solution {
public String getLongestWord(String str) {
// TODO:
}
}
정답
package com.choongang;
public class H_GetLongestWord {
public String getLongestWord(String str) {
// TODO:
String maxLengthString = "";
//str -> 순회하기 위해서 문자열 배열로 변환
String[] strings = str.split(" ");
for (int i = 0; i < strings.length; i++) {
if (maxLengthString.length() < strings[i].length()) {
maxLengthString = strings[i];
}
}
return maxLengthString;
}
}
Test
package com.choongang;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.*;
class H_GetLongestWordTest {
H_GetLongestWord test = new H_GetLongestWord();
@Test
@DisplayName("\"abcd defg 1 B9P RI hijk jB lmno\"을(를) 입력받은 경우, \"abcd\"을(를) 리턴해야 합니다")
void getLongestWord() {
String input = test.getLongestWord("abcd defg 1 B9P RI hijk jB lmno");
assertThat(input).isEqualTo("abcd");
}
@Test
@DisplayName("\"LVLbDCuk 7GOIYvQTyghtBtnk NfG 3mwj eQBZlol x0ycm\"을(를) 입력받은 경우, \"7GOIYvQTyghtBtnk\"을(를) 리턴해야 합니다")
void getLongestWord2() {
String input = test.getLongestWord("LVLbDCuk 7GOIYvQTyghtBtnk NfG 3mwj eQBZlol x0ycm");
assertThat(input).isEqualTo("7GOIYvQTyghtBtnk");
}
@Test
@DisplayName("\"TJ\"을(를) 입력받은 경우, \"TJ\"을(를) 리턴해야 합니다")
void getLongestWord3() {
String input = test.getLongestWord("TJ");
assertThat(input).isEqualTo("TJ");
}
@Test
@DisplayName("\"3 J26V S8oOAvS 2 xlYR KgeTZcrX6XBSOS7 BV KgeTZcrX6XBSOS8\"을(를) 입력받은 경우, \"KgeTZcrX6XBSOS7\"을(를) 리턴해야 합니다")
void getLongestWord4() {
String input = test.getLongestWord("3 J26V S8oOAvS 2 xlYR KgeTZcrX6XBSOS7 BV KgeTZcrX6XBSOS8");
assertThat(input).isEqualTo("KgeTZcrX6XBSOS7");
}
}
9. getEvenNumbers
문제
int 타입를 요소로 갖는 배열을 입력받아 짝수만을 요소로 갖는 배열을 리턴해야 합니다.
입력
인자 1 : arr
- int 타입을 요소로 갖는 배열
- arr[i]는 양의 정수
출력
- int 타입을 요소로 가지는 배열을 리턴해야 합니다.
주의 사항
- 짝수가 없는 경우, 빈 배열을 리턴해야 합니다.
int[] output = getEvenNumbers(new int[]{1, 2, 3, 4});
System.out.println(output); // --> [2, 4]
public class Solution {
public int[] getEvenNumbers(int[] arr) {
// TODO:
}
}
정답
package com.choongang;
import java.util.Arrays;
import static java.util.Arrays.*;
public class I_GetEvenNumbers {
public int[] getEvenNumbers(int[] arr) {
// TODO:
int[] evenArray;
//짝수의 개수 찾기
int count = 0;
for (int i = 0; i < arr.length; i++) {
if (arr[i] % 2 == 0) {
count++;
}
}
evenArray = new int[count];
count = 0;
for (int i = 0; i < arr.length; i++) {
if (arr[i] % 2 == 0) {
evenArray[count] =arr[i];
count++;
}
}
return evenArray;
}
}
Test
package com.choongang;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.in;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
class I_GetEvenNumbersTest {
I_GetEvenNumbers test = new I_GetEvenNumbers();
@Test
@DisplayName("[3, 2, 10, 5, 8]을(를) 입력받은 경우, [2, 10, 8]을(를) 리턴해야 합니다")
void getEvenNumbers() {
int[] input = test.getEvenNumbers(new int[]{3, 2, 10, 5, 8});
int[] arr = new int[]{2, 10, 8};
assertArrayEquals(input, arr);
}
@Test
@DisplayName("[27, 8, 23, 24, 98, 7]을(를) 입력받은 경우, [8, 24, 98]을(를) 리턴해야 합니다")
void getEvenNumbers2() {
int[] input = test.getEvenNumbers(new int[]{27, 8, 23, 24, 98, 7});
int[] arr = new int[]{8, 24, 98};
assertArrayEquals(input, arr);
}
@Test
@DisplayName("빈 배열을 입력받은 경우, 빈 배열을 리턴해야 합니다.")
void getEvenNumbers3() {
int[] input = test.getEvenNumbers(new int[]{});
int[] arr = new int[]{};
assertArrayEquals(input, arr);
}
@Test
@DisplayName("[27, 1, 11, 23, 7]을(를) 입력받은 경우, 빈 배열을 리턴해야 합니다")
void getEvenNumbers4() {
int[] input = test.getEvenNumbers(new int[]{27, 1, 11, 23, 7});
int[] arr = new int[]{};
assertArrayEquals(input, arr);
}
}