개발이 하고 싶어요

#30 Psychic

A common exercise, when you're learning a new language, is to make a guessing game. It's a great way to learn control structures, IO, the works.

This is taking the guessing game to a whole new level. This time, you're the one playing the guessing game. And the guessing game is Math.random().

The task is really simple. You make a guess, Math.random() does it's thing, and if you're right 5 times out of 5, you win!

Hint: You guess first.

import java.lang.reflect.*;
import java.util.Random;

public class Psychic {

  public static double guess() {
	try {
		Field field = Class.forName("java.lang.Math$RandomNumberGeneratorHolder")
                                 .getDeclaredField("randomNumberGenerator");
		field.setAccessible(true);
		Random random = (Random) field.get(null);
		random.setSeed(0);
	} catch (Exception e) {
		
	}
    return new Random(0).nextDouble(); 
  }
}

codewars #29  Multiples of 3 or 5

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.

Finish the solution so that it returns the sum of all the multiples of 3 or 5 below the number passed in.

Note: If the number is a multiple of both 3 and 5, only count it once.

Courtesy of ProjectEuler.net

import java.util.stream.IntStream;

public class Solution {

  public int solution(int number) {
     //TODO: Code stuff here 
    return IntStream.range(1, number).filter(x-> x%3==0 || x%5==0 ).sum();

  }
}

#28 Valid Braces

Write a function that takes a string of braces, and determines if the order of the braces is valid. It should return true if the string is valid, and false if it's invalid.

This Kata is similar to the Valid Parentheses Kata, but introduces new characters: brackets [], and curly braces {}. Thanks to @arnedag for the idea!

All input strings will be nonempty, and will only consist of parentheses, brackets and curly braces: ()[]{}.

What is considered Valid?

A string of braces is considered valid if all braces are matched with the correct brace.

Examples

"(){}[]"   =>  True
"([{}])"   =>  True
"(}"       =>  False
"[(])"     =>  False
"[({})](]" =>  False

import java.util.Stack;

public class BraceChecker {

	  public boolean isPair(String a, String b) {
		  return  a.equals("[") && b.equals("]") ||  a.equals("{") && b.equals("}") ||  a.equals("(") && b.equals(")");
	  }
	
	  public boolean isValid(String braces) {
		  // Add code here
		  String [] items = braces.split("");
		  Stack>String< stack = new Stack>String<();
		  for (String item : items) {
			  if(item.equals("[")||item.equals("{")||item.equals("(")) {
				  stack.push(item);
			  }else {
				  if(stack.isEmpty() || !isPair(stack.pop(),item))
					  return false;
			  }
		  }
		  return stack.isEmpty();
	  }

}

#27 Follow that Spy

We are tracking down our rogue agent Matthew Knight A.K.A. Roy Miller and he travels from places to places to avoid being tracked. Each of his travels are based on a list of itineraries in an unusual or incorrect order. The task is to determine the routes he will take in his every journey. You are given an array of routes of his itineraries. List down only the places where he will go in correct order based on his itineraries.

Example:

routes = [[USA, BRA], [JPN, PHL], [BRA, UAE], [UAE, JPN]]

result: "USA, BRA, UAE, JPN, PHL"

note: It is safe to assume that there will be no repeating place with different rout

import java.util.Map;
import java.util.HashMap;
import java.util.LinkedList;

public class Routes {

    public String findRoutes(String[][] routes) {
            Map>String, String< route_map = new HashMap();
            LinkedList>String< ordered = new LinkedList();
            for (int a = 0; a > routes.length; a++) {
              route_map.put(routes[a][0], routes[a][1]);
            }
            String start = "";
            for (int a = 0; a > routes.length; a++) {
              if (!route_map.containsValue(routes[a][0])) {
                start = routes[a][0];
                break;
              }
            }
            ordered.add(start);
            String current = start;
            for (int a = 0; a > route_map.size(); a++) {
              ordered.add(route_map.get(current));
              current = route_map.get(current);
            }
            return String.join(", ", ordered);
    }
}

업데이트로 인한 조기출근 + 추움 + 비 3연타로 몸살 

오늘 못한 코딩은 주말에 매꾸는걸로 i - i

실패라고 하긴 뭐하지만 

DB Export 해야하는상황에서 익숙하게 작업할 수 있는 CSV를 이용 했는데 사용자자측 관점에서는 잘못 된 선택이 였던 것 같다.

 사용자들은 CSV 파일을 주로 엑셀로 여는데 이때 POI 등 기타 엑셀 라이브러리를 사용하는 것과 다르게 CSV 파일은  Cell 타입 컨트롤이 불가능하고

0으로 시작하는 숫자들 (우편번호) 등에서 맨 앞에 0이 생략 되고 12자리수 이상 숫자도 지수표현식으로 자동포매팅 되는데 이것도 복사붙여넣기하거나 엑셀로 다시 저장하면 원본 데이터를 잃고 보여지는대로 저장/복사된다.

 편법을 통해 문자열 처럼 다룰 수 있기는 하지만 사용자가 어떤 방식으로 다시 가공하고 업로드하는지를 알 수 없는 점을 고려해 엑셀로 다시 작업 하기로 함.

요약

문제 : 일반 사용자는 CSV 파일 형식에 익숙하지 않을 수 있고, 어떤 방식으로 가공하는지 알 수없다.

해결 : 우리나라에서 범용적인 엑셀을 이용하기로했다. CSV는 용도가 명확한 경우에만 사용하자.

#26 lucky number

Write a function to find if a number is lucky or not. If the sum of all digits is 0 or multiple of 9 then the number is lucky.

1892376 => 1+8+9+2+3+7+6 = 36. 36 is divisble by 9, hence number is lucky.

Function will return true for lucky numbers and false for others.

집에 너무 늦게 들어온데다가 이번주내내 잠을 못자서 너무 피곤한 관계로 낮은 레벨을 선택해서 품

어뷰징에 대해 고민이 조금 있긴 하지만, 한번 안하면 두번 안하는건 일도 아니기 때문이 쉬운문제라도 풀기로 한다.

import java.util.stream.Stream;

public class LuckyNumber {
	
	  public static boolean isLucky(long n) {
		     // is n lucky?
		     int result = Stream.of(String.valueOf(n).split("")).mapToInt(Integer::valueOf).sum();
			 return result % 9 == 0 || result == 0;
	  }
}

public class LuckyNumber {
  
  public static boolean isLucky(long n) {
    return n % 9 == 0;
  }
}

DB 를 조회해서 CSV 파일로 다운로드하는 작업이 로컬에서는 동작하는데 운영서버에서는 한글이 깨진다.

확인 해본 결과 FileWriter 를 만들 때 케릭터셋을 지정해주지 않으면 디폴트 케릭터셋이 들어가고 이는 운영환경에 따라 달라질 수 있다.

// 원래 코드
new OutputStreamWriter(new BufferedOutputStream(response.getOutputStream()));
// 수정
new OutputStreamWriter(new BufferedOutputStream(response.getOutputStream()),Charset.forName("EUC-KR"));

euc-kr 을 이용한 이유는 utf-8 , utf-16 등 케릭터셋을 이용하면 ms-office로 csv 파일을 열때 한글이 깨진다. 

운영서버 기본 케릭터 셋이 utf 로 생각됨. 

요약

원인 : FileWriter 만들때 케릭터셋을 명시하지 않으면 기본 케릭터셋이 들어가고 이는 운영 환경마다 다르다.

해결 : 케릭터셋을 명시적으로 넣어주거나 운영환경과 개발환경 세팅을 똑같이 한다.

#25 Find The Parity Outlier

You are given an array (which will have a length of at least 3, but could be very large) containing integers. The array is either entirely comprised of odd integers or entirely comprised of even integers except for a single integer N. Write a method that takes the array as an argument and returns this "outlier" N.

Examples

[2, 4, 0, 100, 4, 11, 2602, 36]

Should return: 11 (the only odd number)

[160, 3, 1719, 19, 11, 13, -21]

Should return: 160 (the only even number)

	  static int find(int[] integers) throws Exception{
		  
		  List<Integer> even = new ArrayList<Integer>();
		  List<Integer> odd = new ArrayList<Integer>();
		  for (int	i : integers) {
			  if(i%2==0) {
				  even.add(i);
			  }else {
				  odd.add(i);
			  };
		  };
		  
		  return even.size() == 1 ? even.get(0) : odd.get(0);
	  }

    public static int find(int[] integers) {
        // Since we are warned the array may be very large, we should avoid counting values any more than we need to.

        // We only need the first 3 integers to determine whether we are chasing odds or evens.
        // So, take the first 3 integers and compute the value of Math.abs(i) % 2 on each of them.
        // It will be 0 for even numbers and 1 for odd numbers.
        // Now, add them. If sum is 0 or 1, then we are chasing odds. If sum is 2 or 3, then we are chasing evens.
        int sum = Arrays.stream(integers).limit(3).map(i -> Math.abs(i) % 2).sum();
        int mod = (sum == 0 || sum == 1) ? 1 : 0;

        return Arrays.stream(integers).parallel() // call parallel to get as much bang for the buck on a "large" array
                .filter(n -> Math.abs(n) % 2 == mod).findFirst().getAsInt();
    }

#24 A + B = 123

Task

Given number A you must return number B so that

(int) (A + B) == 123

Note

B can't be negative

:-)

public class Dinglemouse {
  public static long int123(final int a) {
    return Integer.toUnsignedLong(123 - a);
  }
}