잡다한 배똥월드

function solution(begin, target, words) {

    //words에 target이 없으면 0 리턴
    if (words.indexOf(target) == -1) return 0;
    
    //bfs?를 위해 만든 큐
    let queue = new Array();
    
    //나중에 글자 비교를 위해 target을 문자열 배열로 만들기
    target = target.split("");
    
    //words의 문자들도 문자열 배열로 각각 만들어 담기
    for (i = 0; i < words.length; i++) {
        words[i] = words[i].split("");
    }
    
    //큐에 begin 글자와 변형된 횟수인 0을 매개변수로 Word형으로 만들어 담는다
    queue.push(new Word(begin.split(""), 0));
    
    //큐가 0이 될 때까지 반복
    while (queue.length > 0) {
        //큐의 제일 첫번째 항목 가져오기
        let word = queue.shift();
        
        //항목의 글자와 변형 횟수 가져오기
        let arr = word.w;
        let index = word.index;
        
        //만약 글자가 target과 동일하다면 바로 해당 횟수 리턴
        if (check(arr, target) == 0) return index;
        
        //words의 문자들을 하나씩 꺼내면서 글자와 비교
        for (i = 0; i < words.length; i++) {
            let count = words[i].length;
            
            for (j = 0; j < words[i].length; j++) {
                if (arr[j] == words[i][j]) count--;
            }
            
            //만약 글자 차이가 1개 밖에 없으면 큐에 넣으면서 words에서는 삭제
            if (count == 1) {
                queue.push(new Word(words[i], index+1));
                words.splice(i, 1);
            }
        }
    }
    
    //while문이 끝나면 변형할 수 없는 것이기 때문에 0 리턴
    return 0;
}

function check(w1, w2) {
    let count = w1.length;
    for (i = 0; i < w1.length; i++) {
        if (w1[i] == w2[i]) count--;
    }
    return count;
}

class Word {
    constructor(word, i) {
        this.w = word;
        this.index = i;        
    }
}

▽ Stream으로 계산하는 코드 ▽ 

import java.io.*;
import java.util.Arrays;
public class Main {	
	public static void main(String[] args) throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		
		int n = Integer.parseInt(br.readLine());
		
		for (int t = 0; t < n; t++) {
			//Stream을 이용하여 String[]을 int[]로 변환하는 방법
			int[] list = Arrays.stream(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
			
			int num = list[0];
			int[] score = Arrays.copyOfRange(list, 1, list.length);
			
			//Stream을 이용하여 int배열 내 숫자의 총 합을 내는 방법
			double avg = Arrays.stream(score).sum() / num;

			//Stream을 이용하여 int배열 내 숫자들 중 조건에 맞는 숫자들 개수 구하는 방법
			double count = Arrays.stream(score).filter(number -> number > avg).count();

			bw.write(String.format("%.3f", count / num * 100) + "%\n");
		}
		bw.flush();
		bw.close();
	}
}

▽ for문으로 계산하는 코드 ▽

import java.io.*;
public class Main {	
	public static void main(String[] args) throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		
		int n = Integer.parseInt(br.readLine());
		
		for (int t = 0; t < n; t++) {
			String[] temp = br.readLine().split(" ");

			int num = Integer.parseInt(temp[0]);
			int[] score = new int[num];
			
			int sum = 0;
			for (int i = 1; i < temp.length; i++) {
				score[i-1] = Integer.parseInt(temp[i]);
				sum += score[i-1];
			}
			
			double avg = sum / num;
			int count = 0;
			for (int i = 0; i < score.length; i++) {
				if (score[i] > avg) count++;
			}
			
			bw.write(String.format("%.3f", (double) count / num * 100) + "%\n");
		}
		bw.flush();
		bw.close();
	}
}

import java.io.*;
public class Main {
	public static void main(String[] args) throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		//입력 첫 줄은 행과 열을 나타내는 숫자
        	String[] rc = br.readLine().split(" ");
		int r = Integer.parseInt(rc[0]);
		int c = Integer.parseInt(rc[1]);
		
        	//그 다음 줄 부터는 성의 상태
		String[][] map = new String[r][c];
		
        	//출력을 위해 체크용.
       		//행에 배치해야할 경비 수와 열에 배치해야할 경비 수
		int rCount = 0;
		int cCount = 0;
        
       		//열은 바로바로 체크가 안되니까 한 줄씩 비어있는지 아닌지를 파악하기 위해 boolean 배열
		boolean[] cCheck = new boolean[c];
		
        	//한 줄 씩 입력 받으면서 해당 행에 경비가 있는지 => 없으면 rCount +1 
		//해당 열에 경비가 있으면 cCheck 상태 바꾸기
		for (int i = 0; i < r; i++) {
			map[i] = br.readLine().split("");
			boolean value = false;
			for (int j = 0; j < c; j++) {
				if (map[i][j].equals("X")) {
					if (!value) value = true;
					if (!cCheck[j]) cCheck[j] = true;
				}
			}
			if (!value) rCount++;
		}
		
        	//cCheck를 돌면서 빈 경비 개수 세기
		for (int i = 0; i < c; i++) {
			if (!cCheck[i]) cCount++;
		}
        
       		//rCount와 cCount 중 큰 숫자 리턴
		System.out.println(Math.max(rCount, cCount));
	}
}

Map 생성자

new Map() 생성자를 사용

set(키, 값)

데이터를 저장할 때 파라미터로 키와 값을 이용

get(키)

저장된 데이터를 읽을 때 파라미터로 얻고자 하는 값의 키를 전달

has(키)

특정 키의 값이 저장되어 있는지 확인

delete(키)

저장되어 있는 특정 데이터를 삭제

clear()

저장되어 있는 모든 데이터를 한 번에 삭제

forEach()

저장되는 모든 데이터를 읽을 때 사용

toString()

배열 안의 모든 문자를 쉼표(,)를 이용해 모두 결합해서 하나의 문자열로 반환

join()

배열 안의 모든 문자를 파라미터로 지정한 문자를 이용해서 모두 결합해서 하나의 문자열로 반환

pop()

배열에서 마지막 데이터를 제거하고, 마지막 데이터를 반환

push()

배열에 새로운 요소를 추가

shift()

배열에서 첫 번째 요소를 제거하고, 첫 번째 요소를 반환

unshift()

배열의 맨 앞에 요소를 추가하고, 배열의 길이를 반환

splice()

새로운 요소를 특정 위치에 추가

첫 번째 파라미터 : 새로운 요소를 추가할 인덱스 번호

두 번째 파라미터 : 첫 번째 파라미터에 해당하는 인덱스에서 요소를 추가하기 전 삭제할 요소 수

나머지 파라미터 : 추가할 요소

concat()

2개 이상의 배열을 하나의 배열로 결합

slice()

시작 인덱스 번호부터 종료 인덱스 번호 이전까지의 배열 요소를 잘라내서 배열 형태로 반환

첫 번째 파라미터 : 시작 인덱스 번호

두 번째 파라미터 : 종료 인덱스 번호 (생략 가능, 생략 시 마지막 배열 요소까지)

sort()

배열에 문자형 데이터가 있는 경우 오름차순으로 정렬

sort(function(a, b){     })

인수로 전달된 function(a, b){     }를 통해 정렬됨

filter(callback(element[, index[, array]])[, thisArg])

배열에서 특정 조건을 만족하는 배열의 요소만을 찾아서 새로운 배열로 반환

callback() : 배열의 각 요소를 시험할 함수. true인 요소만 찾아내는 함수

element : 처리할 현재 요소

index(optional) : 처리할 현재 요소의 인덱스

array(optional) : 배열 전체

map()

배열의 데이터가 Object형일 때, 배열에 담긴 Object를 새로운 형태의 Object로 변환해서 배열로 반환

reduce(callback())

배열에 담긴 데이터를 하나씩 순회하며 callback 함수의 실행 값을 누적하여 결과값을 반환하는 함수

callback 함수 첫 번째 매개변수 : accumulator (누적 값)

callback 함수 두 번째 매개변수 : currentValue (현재 배열의 요소)

callback 함수 세 번째 매개변수 : currentIndex (인덱스 번호)

callback 함수 네 번째 매개변수 : arr (배열)

import java.io.*;
import java.util.*;
public class Main {	
	public static void main(String[] args) throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
        //가져올 단어 개수
		int n = Integer.parseInt(br.readLine());
		
        //단어를 String배열로 변환하여 담을 arraylist
        ArrayList<String[]> arr = new ArrayList<>();
		
        //arr에 담기
		for (int i = 0; i < n; i++) {
			arr.add(br.readLine().split(""));
		}
		
        //리턴할 문자열 배열
		String[] result = Arrays.copyOf(arr.get(0), arr.get(0).length);
		
    	앞에서부터 비교해서 만약 문자가 다르면 ?로 변환
		for (int i = 0; i < n; i++) {
			String[] a = arr.get(i);
			for (int j = i+1; j < n; j++) {
				String[] b = arr.get(j);
				for (int k = 0; k < a.length; k++) {
					if (!a[k].equals(b[k]) && !result[k].equals("?")) {
						result[k] = "?";
					}
				}
			}
		}
        
        //String.join함수로 묶은 후 리턴
		System.out.println(String.join("", result));	
	}
}

셀 서식의 사용자 지정 표시 형식 말고도 TEXT함수를 이용하여 셀 서식을 지정할 수 있음

=TEXT(서식을 지정할 값, "적용할 서식 코드")

이 때, 적용할 서식 코드 자리에 넣을 서식 코드를 정리하고자 한다.

▽ 마이크로소프트에서 제공하는 서식 코드 정리표 ▽

▽ 내가 정리한 서식 코드 정리표 ▽

이후 새로 알게 된 내용은 추가로 수정하겠음

import java.util.*;
class Solution {
    public int solution(String begin, String target, String[] words) {
    
    	//words에 target이 있는지 없는지 확인
        boolean value = false;
        for (int i = 0; i < words.length; i++) {
            if (words[i].equals(target)) {
                value = true;
                break;
            }
        }
        if (!value) return 0;
        
        //words의 단어들을 비교하기 편하게 char배열로 변환 후 ArrayList에 넣기
        ArrayList<char[]> list = new ArrayList<>();
        for (int i = 0; i < words.length; i++) {
            list.add(words[i].toCharArray());
        }
        
        //target도 한번씩 확인을 해야하기 때문에 미리 char배열로 만들어놓기
        char[] base = target.toCharArray();
        
       	//너비우선탐색인 BFS로 탐색하기 위해서 Queue 선언
        Queue<word> q = new LinkedList<>();
        
        //큐에 begin을 char배열로 변환하여 word 객체로 만들어서 넣기
        q.add(new word(0, begin.toCharArray()));
        
        //q가 비워질 때까지 반복
        while (!q.isEmpty()) {
        	//큐의 제일 상단 값 가져오기
            word w = q.poll();
            char[] temp = w.list;
            int index = w.index;
            
            //temp와 target이 같은지 안같은지 비교. 같으면 해당 index 리턴
            if (check(base, temp) == 0) return index;

			//temp와 list에 있는 단어들 비교
            for (int i = 0; i < list.size(); i++) {
                char[] data = list.get(i);
                //글자가 하나만 다르면 list에서 지우면서 q에 넣기
                if (check(temp, data) == 1) q.add(new word(index+1, list.remove(i)));
            }
        }
        return 0;
    }
    
    //a 글자와 b 글자가 몇 글자 다른지 비교하는 함수
    public int check(char[] a, char[] b) {
        int count = a.length;
        for (int i = 0; i < a.length; i++) {
            if (a[i] == b[i]) count--;
        }
        
        return count;
    }
}

class word {
    int index;
    char[] list;
    public word (int i, char[] list) {
        this.index = i;
        this.list = Arrays.copyOf(list, list.length);
    }
}