IT 기술 따라잡기

오늘의 문제는 스트링 배열 들이 공통으로 가지고 있는 prefix 를 찾는 문제 입니다.

이 문제를 다루려면 우선 String API 중 indexOf() 와 substring() 메소드를 알아야 합니다.

IndexOf()는 원하는 글자가 어떤 스트링 에 몇번째에 있는지 알 수 있는 메소드 입니다. 그 글자가 없으면 -1이 반환됩니다.

Substring()은 해당 스트링의 일부 문자만 가져오고 싶을 때 사용합니다.

이 두 메소드를 활용해서 만든  코드는 아래와 같습니다.

로직은 우선 첫번째 String과 두번째 String의 prefix부터 먼저 구하고 나머지를 순차적으로 구하는 겁니다.

알아보기 쉽게 하기 위해서 여러곳에 System.out.println()을 넣었습니다.

우선 루프 이전을 살펴보면...

class Solution { // 클래스 이름은 Solution

    public String longestCommonPrefix(String[] strs) { // 메소드 이름은 longestCommonPrefix 이고 입력값으로 스트링 배열인 strs를 받고 출력값은 String 이 됩니다.

        String returnValue = ""; // 일단 출력할 String 변수를 생성했습니다. 초기값은 "" 로 했습니다.

        if(strs.length == 0) return returnValue; // 입력값이 없으면 "" 를 반환합니다.

        String prefix = strs[0]; // prefix에 입력값의 첫번째 스트링을 넣습니다.

일단 입력값은 ["flower","flow","flight", "flown"] 로 가정하겠습니다.

여기서 prefix 는 첫번째 스트링인 flower가 됩니다.

이제 루프문을 보겠습니다.

for(int i=1; i < strs.length; i++) { // 루프는 입력값의 스트링 숫자만큼 돕니다. 이 경우에는 4번 돕니다.

            System.out.println(i + " prefix is " + prefix); // 위에 설정했듯이 첫번째 루프에서 prefix는 flower 입니다.

            System.out.println(i + " strs is " + strs[i]); // 첫번쨰 루프에서는 strs[1]이니까 두번쨰 스프링인 flow가 그 값이 됩니다.

            while(strs[i]. indexOf(prefix) !=0) { // 이걸 풀면 flow.indexOf(flower)가 되고 flow안에는 flower가 없으니까 -1이 되서 while문을 안으로 들어가게 됩니다.

                prefix = prefix.substring(0, prefix.length() - 1); // prefix가 없으니까 prefix에서 맨 마지막 글자를 뺍니다. 그러면 flower에서 r이 빠져서 prefix는 이제 flowe가 됩니다.

                System.out.println(i + " in while prefix is " + prefix); // prefix가 flowe가 됐으니까 stout에 flow가 출력 됐습니다.

                if(prefix.isEmpty()) return returnValue; //prefix가 empty 일 경우 return 하는데 이 경우에는 실행 되지 않습니다.

            }

        }

이제 prefix가 flowe가 된 상태에서 다시 시작 합니다.

While 문을 보면 flow.indexOf(flowe)가 되기 때문에 여전히 -1 입니다.

그러면 prefix는 flowe에서 e가 빠진 flow가 됩니다.

그러면 다시 while문을 돌게 되죠.

이번에는 flow.indexOf(flow)가 되기 때문에 while문은 0 이 되기 때문에 이 while문을 빠져 나와서 for문을 다시 돌게 됩니다.

이제 i 는 ++ 가 되서 2가 됩니다.

그러면 이제 flight을 비교 하게 됩니다.

첫번째 while 문에서는 flow.indexOf(flight) 가 되서 -1 이므로 while 문 안으로 들어가게 됩니다.

그러면 flow에서 w가 빠져서 flo가 됩니다.

While문이 다시 돌게 되고 flo.indexOf(flight)는 -1이므로 prefix는 다시 fl로 바뀝니다.

다음 while문에서는 fl.indexOf(flight)이 0이 되므로 while문을 빠져 나와서 다시 for 문으로 갑니다.

이제 i 는 3이 되고 strs[3] 이마로 flown을 비교하게 됩니다.

prefix는 이제 fl입니다.

이제 while문에서 fl.indexOf(flight)이 되므로 while문은 그냥 빠져 나오게 됩니다.

그럼 다시 for 문으로 가는데 i 는 4가 되서 strs.length와 같게 되기 때문에 for 문도 빠져 나오게 됩니다.

For 문을 빠져 나오면서 아래 코드를 만나게 됩니다.

returnValue = prefix; // prefix 가 fl이 됐기 때문에 returnValue에는 이 값이 할당 됩니다.

        return returnValue; // 그 값을 return 합니다.

    }

}

이 로직은 이렇게 됩니다.

전체 코드를 다시 보면 이렇습니다.

class Solution {

    public String longestCommonPrefix(String[] strs) {

        String returnValue = "";

        if(strs.length == 0) return returnValue;

        String prefix = strs[0];

        for(int i=1; i < strs.length; i++) {

            while(strs[i]. indexOf(prefix) !=0) {

                prefix = prefix.substring(0, prefix.length() - 1);

                if(prefix.isEmpty()) return returnValue;

            }

        }

        returnValue = prefix;

        return returnValue;

    }

}

이 외에 다른 접근 법으로는 아래와 같은 것들이 있습니다.

Approach 2: Vertical scanning

public String longestCommonPrefix(String[] strs) {
    if (strs == null || strs.length == 0) return "";
    for (int i = 0; i < strs[0].length() ; i++){
        char c = strs[0].charAt(i);
        for (int j = 1; j < strs.length; j ++) {
            if (i == strs[j].length() || strs[j].charAt(i) != c)
                return strs[0].substring(0, i);             
        }
    }
    return strs[0];
}

Strs[0] 은 flower가 됩니다.

for문은 이 flower의 글자 수(6) 만큼 돌리게 됩니다.

우선 char c에는 f가 담기게 되죠. 

두번째 for 문은 입력된 String 갯수 만큼 돕니다.

입력값이  ["flower","flow","flight", "flown"] 이면 두번째 for 문은 4번 돌겠다.

If 문에서는 두번째 스트링이 empty거나 empty가 아니더라도 첫번째 글자가 f가 아니면 empty를 반환합니다.

If에 걸리지 않으면 계속 두번째 for 문을 돕니다. 

모든 스트링이 if 문에 걸리지 않았다면 모두 f는 공통으로 가지고 있다는 것이 됩니다.

그러면 다시 첫번째 for 문으로 가서 i 가 1이 되고 char c 는 fl이 됩니다.

두번째 for 문이 돌게 되는데 모든 스트링이 다 fl을 가지고 있으므로 두번째 for 문을 빠져 나와서 첫번째 for 문을 다시 돌게 됩니다.

이제 i는 2가 되고 char c 는 flo가 됩니다.

이제는 두번째 for 문 안에 있는 if 문에 걸리게 됩니다.

그러면 그 if 문 안에 있는 strs[0].substring(0,i); 이 실행 되게 되고 i는 2 이기 때문에 fl 이 리턴되게 됩니다.

다른 방법도 있습니다.

Approach 3: Divide and conquer

public String longestCommonPrefix(String[] strs) {
    if (strs == null || strs.length == 0) return "";    
        return longestCommonPrefix(strs, 0 , strs.length - 1);
}

private String longestCommonPrefix(String[] strs, int l, int r) {
    if (l == r) {
        return strs[l];
    }
    else {
        int mid = (l + r)/2;
        String lcpLeft =   longestCommonPrefix(strs, l , mid);
        String lcpRight =  longestCommonPrefix(strs, mid + 1,r);
        return commonPrefix(lcpLeft, lcpRight);
   }
}

String commonPrefix(String left,String right) {
    int min = Math.min(left.length(), right.length());       
    for (int i = 0; i < min; i++) {
        if ( left.charAt(i) != right.charAt(i) )
            return left.substring(0, i);
    }
    return left.substring(0, min);
}

--------------

Approach 4: Binary search

public String longestCommonPrefix(String[] strs) {
    if (strs == null || strs.length == 0)
        return "";
    int minLen = Integer.MAX_VALUE;
    for (String str : strs)
        minLen = Math.min(minLen, str.length());
    int low = 1;
    int high = minLen;
    while (low <= high) {
        int middle = (low + high) / 2;
        if (isCommonPrefix(strs, middle))
            low = middle + 1;
        else
            high = middle - 1;
    }
    return strs[0].substring(0, (low + high) / 2);
}

private boolean isCommonPrefix(String[] strs, int len){
    String str1 = strs[0].substring(0,len);
    for (int i = 1; i < strs.length; i++)
        if (!strs[i].startsWith(str1))
            return false;
    return true;
}

----------------------------

public String longestCommonPrefix(String q, String[] strs) {

    if (strs == null || strs.length == 0)

         return "";  

    if (strs.length == 1)

         return strs[0];

    Trie trie = new Trie();      

    for (int i = 1; i < strs.length ; i++) {

        trie.insert(strs[i]);

    }

    return trie.searchLongestPrefix(q);

}

class TrieNode {

    // R links to node children

    private TrieNode[] links;

    private final int R = 26;

    private boolean isEnd;

    // number of children non null links

    private int size;    

    public void put(char ch, TrieNode node) {

        links[ch -'a'] = node;

        size++;

    }

    public int getLinks() {

        return size;

    }

    //assume methods containsKey, isEnd, get, put are implemented as it is described

   //in  https://leetcode.com/articles/implement-trie-prefix-tree/)

}

public class Trie {

    private TrieNode root;

    public Trie() {

        root = new TrieNode();

    }

//assume methods insert, search, searchPrefix are implemented as it is described

//in  https://leetcode.com/articles/implement-trie-prefix-tree/)

    private String searchLongestPrefix(String word) {

        TrieNode node = root;

        StringBuilder prefix = new StringBuilder();

        for (int i = 0; i < word.length(); i++) {

            char curLetter = word.charAt(i);

            if (node.containsKey(curLetter) && (node.getLinks() == 1) && (!node.isEnd())) {

                prefix.append(curLetter);

                node = node.get(curLetter);

            }

            else

                return prefix.toString();

         }

         return prefix.toString();

    }

}

오늘의 문제는 로마 숫자를 아라비아 숫자로 바꾸는 로직을 만드는 것이다.

우선 로마자의 규칙 부터 알아야 한다.

위 그림에서 나왔듯이 M은 1000 이고 ... I 는 1 이다.

그러면 순서대로 MDCLXVI 이렇게 쓰면 이건 아라비아 숫자로 무엇일까?

일단 M은 1000이고 D는 500 이다. 그러면 여기 끼지는 두 숫자를 더해서 1500이 된다.

그런데 다음은 C이고 100을 의미한다. 그러면 1500에서 100을 더해서 1600이 된다.

이렇게 숫자들을 더하면 된다. 

그러면 1600 + 50 (L) + 10 (X) + 5 (V) + 1 (I) = 1666.

이렇게 MDCLXVI는 1666을 의미한다.

1. 여기서 알아낸 첫번째 규칙은 각각의 로마자에 대입되는 숫자들을 더하는데 기본 규칙이라는 것을 알 수 있다.

그러면 MCM는 어떻게 될까?

첫번째 M은 1000이다. 두번째 C는 100이다. 그리고 세번째 다시 M 즉 1000 이다.

단순히 이 세계를 더하는데 답일까? (1000 + 100 + 1000 = 2100 ???)

아니다. 여기서 한가지 더 알아야 한다.

900을 표시하기 위해서 C를 아홉 번 쓴다던가 D를 한번 쓰고 C를 4번 써서 900을 표시하지 않는다.

1000 쪽에 100을 쓰면 이건 빼라는 얘기다.

즉 CM 이렇게 쓰면 1000 (M) - 100 (C) = 900이 된다.

2. 여기서 두번째 규칙이 나온다. 현재 숫자보다 다음 숫자가 더 클 경우는 다음 숫자에서 현재 숫자를 뺀다이다.

MCMXCIV는 어떨까?

1000 + 900 (M-C) + 90 (C - X) + 4 (V-I) = 1994 가 정답이 된다.

이 두가지 규칙을 로직화 한게 아래 코드 이다.

class Solution { // 클래스 이름은 Solution 이다.

    static Map<String, Integer> values = new HashMap<>(); // 로마자와 아라비아 숫자를 키 밸류 쌍으로 다루기 위해 해쉬맵을 선언했다.

    static { // 로마숫자와 아라비아 숫자 쌍을 key - value 형식으로 HashMap에 put 한다.

        values.put("M", 1000);

        values.put("D", 500);

        values.put("C", 100);

        values.put("L", 50);

        values.put("X", 10);

        values.put("V", 5);

        values.put("I", 1);

    }

    public int romanToInt(String s) {

        int sum = 0; // return 할 int 변수를 선언 한다.

        int i = 0; // 루프에서 사용될 int 변수를 선언한다. 

        while(i<s.length()) { // 입력값의 글자 숫자 만큼 반복한다.

            String currentSymbol = s.substring(i, i + 1); // 입력값의 맨 i 번째 문자를 currentSymbol에 담는다.

            int currentValue = values.get(currentSymbol); // currentSymbol에 해당하는 아라비아 숫자를 currentValue에 담는다.

            int nextValue = 0; // 다름 숫자를 담을 int 변수를 선언한다. 

            if(i + 1 < s.length()) { // 입력값의 맨 마지막 글자까지 가지 않았다면 이 if 문을 실행한다.

                String nextSymbol = s.substring(i + 1, i+2); // currentSymbol 다음 글자를 nextSymbol에 담는다.

                nextValue = values.get(nextSymbol); // nextSymbol에 해당하는 아라비아 숫자를 nextValue에 담는다.

            }

            if(currentValue < nextValue) { // 현재 값이 다음 값보다 작을 경우 아래를 실행한다.

                sum += (nextValue - currentValue); // sum은 sum + (nextValue-currentValue) 가 된다.

                i += 2; // 입력값의 두 문자에 대해 실행 했기 때문에 두칸을 건너 뛰기 위해 i 에 2를 더한다.

            } else { // 현재 값이 다음 값보다 같거나 클 경우 아래를 실행한다.

                sum += currentValue; // 그냥 sum에다가 currentValue를 더한다.

                i +=1; // 한 글자에 대해서만 처리했으므로 i에 1을 더한다.

            }

        }

        return sum; // sum 값을 return 한다.

    }

}

이것과 같은 Python 스크립트는 아래와 같다.

values = {
    "I": 1,
    "V": 5,
    "X": 10,
    "L": 50,
    "C": 100,
    "D": 500,
    "M": 1000,
}

class Solution:
    def romanToInt(self, s: str) -> int:
        total = 0
        i = 0
        while i < len(s):
            # If this is the subtractive case.
            if i + 1 < len(s) and values[s[i]] < values[s[i + 1]]:
                total += values[s[i + 1]] - values[s[i]]
                i += 2
            # Else this is NOT the subtractive case.
            else:
                total += values[s[i]]
                i += 1
        return total

조금 다르게 접근할 수도 있다.

아예 로마숫자와 아라비아 숫자 매칭을 아래와 같이 할 수 있다.

class Solution {
    
    static Map<String, Integer> values = new HashMap<>();

    static {
        values.put("I", 1);
        values.put("V", 5);
        values.put("X", 10);
        values.put("L", 50);
        values.put("C", 100);
        values.put("D", 500);
        values.put("M", 1000);
        values.put("IV", 4);
        values.put("IX", 9);
        values.put("XL", 40);
        values.put("XC", 90);
        values.put("CD", 400);
        values.put("CM", 900);
    }

이렇게 매칭을 만들면 로직은 아래와 같이 바꾸면 된다.

    public int romanToInt(String s) {
        
        int sum = 0;
        int i = 0;
        while (i < s.length()) {
            if (i < s.length() - 1) {
                String doubleSymbol = s.substring(i, i + 2); // 아예 처음부터 입력값의 글자 두 개를 불러 온다.
                // Check if this is the length-2 symbol case.
                if (values.containsKey(doubleSymbol)) { // 그 키 값이 위 매핑에 있다면 
                    sum += values.get(doubleSymbol); // 해당 값을 가져오고
                    i += 2; // 문자 두 개를 처리 했으니 i에 2를 더한다.
                    continue;
                }
            }
            // Otherwise, it must be the length-1 symbol case. 두 글자가 매핑에 없다면 
            String singleSymbol = s.substring(i, i + 1); // 한 글자만 불러와서 
            sum += values.get(singleSymbol); // sum 에 더해 준다.
            i += 1; // 한 글자만 처리했으니 i 에 1을 더해 준다.
        }
        return sum; // 결과 값을 리턴한다.
    }
}

여기에 해당하는 Python 코딩은 아래와 같다.

values = {
    "I": 1,
    "V": 5,
    "X": 10,
    "L": 50,
    "C": 100,
    "D": 500,
    "M": 1000,
    "IV": 4,
    "IX": 9,
    "XL": 40, 
    "XC": 90,
    "CD": 400,
    "CM": 900
}

class Solution:
    def romanToInt(self, s: str) -> int:
        total = 0
        i = 0
        while i < len(s):
            # This is the subtractive case.
            if i < len(s) - 1 and s[i:i+2] in values:
                total += values[s[i:i+2]] 
                i += 2
            else:
                total += values[s[i]]
                i += 1
        return total

위 두 개는 입력값 을 왼쪽에서 오른쪽으로 보면서 계산한 것이다.

입력값을 오른쪽에서 부터 계산하는 방법도 생각해 볼 수 있다.

class Solution {
    
    static Map<String, Integer> values = new HashMap<>();
    
    static {
        values.put("M", 1000);
        values.put("D", 500);
        values.put("C", 100);
        values.put("L", 50);
        values.put("X", 10);
        values.put("V", 5);
        values.put("I", 1);
    }

    public int romanToInt(String s) {
        
        String lastSymbol = s.substring(s.length() - 1); // 맨 마지막 - 오른쪽 - 글자를 가져온다.
        int lastValue = values.get(lastSymbol); // 오른쪽 로마자에 해당하는 아라비아 숫자를 가져온다.
        int total = lastValue; // 리턴할  int 변수를 생성했다. 값은 lastValue를 넣었다.

        for (int i = s.length() - 2; i >= 0; i--) { // 입력값 -1 만큼 for 문을 돌린다. i 는 맨 마지막 글자 이전 부터 시작할 수 있도록 한다.
            String currentSymbol = s.substring(i, i + 1); // 현재값을 구한다. (첫번째 루프실행의 경우 맨 오른쪽에서 두번째 글자)
            int currentValue = values.get(currentSymbol); // 현재 값에 해당하는 아라비아 숫자를 구한다.
            if (currentValue < lastValue) { // 현재 값이 lastValue보다 작다면 
                total -= currentValue; // total = total - currentValue를 한다. 첫번쨰 루프에서 total은 lastValue가 된다.
            } else { // 현재 값이 lastValue보다 크거나 같다면
                total += currentValue; // total = total + currentValue를 한다. 
            }
            lastValue = currentValue; // lastValue에 currentValue를 입력한다.
        }
        return total; // for 문을 다 돌린 후 total 값을 리턴한다.
    }
}

여기에 해당하는 Python 스크립트는 아래와 같다.

values = {
    "I": 1,
    "V": 5,
    "X": 10,
    "L": 50,
    "C": 100,
    "D": 500,
    "M": 1000,
}

class Solution:
    def romanToInt(self, s: str) -> int:
        total = values.get(s[-1])
        for i in reversed(range(len(s) - 1)):
            if values[s[i]] < values[s[i + 1]]:
                total -= values[s[i]]
            else:
                total += values[s[i]]
        return total

오늘의 문제는 9. Palindrome Number 입니다.
앞으로 해도 뒤로 해도 똑같은 우병우 가 아니라
앞으로 해도 뒤로 해도 똑같은 숫자를 구별하라는 문제 입니다.

제가 만든 스크립트는 아래와 같습니다.

class Solution {
public boolean isPalindrome(int x) {
boolean returnValue = true; // 일단 리턴 값을 담을 변수를 만들고 초기값은 true로 설정한다.
String temp = Integer.toString(x); // 나중에 charAt을 사용할 예정이므로 int 입력값 을 스프링으로 변환한다.

int left = 0; // left는 0
int right = temp.length()-1; // right는 입력값 길이 -1

while(left < right) { // left 가 right 보다 작을 때까지 while 문 실행
if(temp.charAt(left++) != temp.charAt(right--)){ // 입력값의 왼쪽 값과 오른쪽 값이 다를 경우 if 문 실행
returnValue = false; // 다를 경우 리턴값은 false 가 된다.
}
}

return returnValue; // 리턴값을 리턴한다.
}
}

다른 사람이 만든 스크립트를 보자.

class Solution {
    public boolean isPalindrome(int x) {
        String s1 = Integer.toString(x);
        //passing x in the below statement won't work(idk why)
        StringBuilder s2 = new StringBuilder(s1).reverse();
        return s2.toString().equals(s1);
        //s2.toString() == s1 -> compares string references --> hence use .equals()
    }
}

내꺼 보다 훨씬 간단하다.
이 사람은 StringBuilder의 reverse 함수를 사용했다.
원래 입력값과 reverse한 값이 같으면 true 다르면 false를 리턴한다.

Python 으로는 아래와 같이 할 수 있다.

class Solution:
    def isPalindrome(self, x: int) -> bool:
        s = str(x)
        return s == s[::-1]

마지막 줄이 좀 이해가 안기는데......

list[<start>:<stop>:<step>]

• start (optional)- Starting index value where the slicing of the object starts. Default to 0 if not provided.
• stop – Index value until which the slicing takes place.
• step (optional) – Index value steps between each index for slicing. Defaults to 1 if not provided.

문법은 이렇다. 그리고 이렇게 작동한다.

>>> a = '1234'
>>> a[::-1]
'4321'

Step이 -1 이면 reverse를 하기된다.

a = '1234'
print a[::2]

13

스텝이 2 이면 한 개 건너 뛴 값이 선택 된다.

a = '1234'
print a[3:0:-1]

432

이렇게 되면 세번째 까지만 리버스 된다.

a = [1, 2, 3, 4, 5, 6, 7, 8] print(a[:5]) ==> output 1,2,3,4,5

a = [1, 2, 3, 4, 5, 6, 7, 8]
print(a[3:])

Output: [4, 5, 6, 7, 8]

a = [1, 2, 3, 4, 5, 6, 7, 8]
print(a[3:5])

Output: [4, 5]

a = [1, 2, 3, 4, 5, 6, 7, 8]
print(a[3:7:2])

Output: [4, 6]

a = [1, 2, 3, 4, 5, 6, 7, 8]
print(a[:5])    # prints [1, 2, 3, 4, 5]
print(a[2:])    # prints [3, 4, 5, 6, 7, 8]
print(a[2:5])    # prints [3, 4, 5]
print(a[2:7:2])    # prints [3, 5, 7]

You can index the last index of a sequence by using  -1 :

a = [1, 2, 3, 4, 5, 6]
print(a[-1])    # prints 6
print(a[2:-1])    # prints [3, 4, 5]

You can flip a sequence by using the  [::-1] slice notation:

a = [1, 2, 3, 4, 5, 6]
print(a[::-1])    # prints [6, 5, 4, 3, 2, 1]

지금 in between jobs 상태라서 취업 면접을 보고 있다.

어제 한 회사의 테크니컬 인터뷰를 봤다.

한 문제가 나왔는데 아래가 그 문제다.

String input을 reverse 하는데 letter 별로 하는게 아니라 단어별로 하라는 거다.

그래서 결과는 output과 같아야 한다는 것이다.

그 자리에서 나름대로 스크립팅를 해서 만들게 아래 코드다.

다행히도 원하는 결과물의 만들었다.

그래서 테크니컬 인터뷰는 통과 했다.

로직은 이전에 했던 String 의 letter들을 reverse 하는 것과 같다. 다면 단어를 reverse 해야 하는데 이건 letter 별이 아니라 단어별로 끊어서 배열에 넣으면 된다고 생각했다.

class HelloWorld { // 클래스 이름. 그냥 신경 안 쓰고 HelloWorld로 했다.
    public static void main(String[] args) { // 메인 함수
        String input = "Reverse words in a sentence."; // 입력값
        String output = "sentence. a in words Reverse"; // 원하는 출력 값
        
       System.out.println(reverseWords(input)); // reverseWords라는 메소드에 입력값을 보내고 그 결과를 프린트 한다.
    }
    
    public static String reverseWords(String input) { // reverseWords 메소드 입력값은 input 스트링 return은 스트링 타입이다.
        String returnValue; // return 할 스트링 변수를 만든다.
        
        String[] tempInput = input.split(" "); // input 을 단어별로 나눠서 스트링 배열에 담는다.
        int left = 0; 
        int right = tempInput.length -1;
        
        while(left < right) { // left가 right 보다 작을 때까지 while문을 돌린다.
            String temp = tempInput[left]; // 스프링에 배열 맨 왼쪽 값을 넣는다.
            tempInput[left++] = tempInput[right]; // 맨 왼쪽에 맨 오른쪽 단어를 넣는다.
            tempInput[right--] = temp; // 오른쪽에 맨 왼쪽 값을 넣는다.
        }
        
       returnValue = tempInput[0]; // returnValue에 배열의 맨 첫번째 값을 담는다.
        
        for(int i=1; i < tempInput.length; i++) { // 배열의 갯수보다 1 작은 만큼 for 문을 돌린다.
            returnValue = returnValue + " " + tempInput[i]; // 각 배열의 값들을 하나의 스트링 으로 만든다.
        }
        
        return returnValue; // 만든 스트링 을 리턴한다.
    }
}

결과 값은 오른쪽 Output 패널에 보이는 대로 원하는 값을 얻을 수 있었다.

다행히 문제를 제대로 풀 수 있어서 통과 했다.