명품 JAVA Programming 7장 실습문제 정답

 

명품 JAVA Programming 7장 실습문제 정답

 

명품 JAVA Programming 7장 실습문제 정답

 

1번

import java.util.*;

public class VectorBig {
	
	public static void printBig(Vector<Integer> v) {  // 벡터 v의 정수 중 가장 큰 수 출력
		int big = v.get(0); // 맨 처음에 있는 수를 제일 큰 수로 초기화
		for(int i=1; i<v.size(); i++) {
			if(big < v.get(i))  // 더 큰 수 발견
				big = v.get(i); // big 변수 교체
		}
		
		System.out.println("가장 큰 수는 " + big);		
	}
	
	public static void main(String[] args) {
		Vector<Integer> v = new Vector<Integer>();
		Scanner scanner = new Scanner(System.in);
		
		System.out.print("정수(-1이 입력될 때까지)>> ");
		while(true) {
			int n = scanner.nextInt();
			if(n == -1) // 입력된 수가 -1이면
				break;
			v.add(n);
		}
		
		if(v.size() == 0) {
			System.out.print("수가 하나도 없음");
			scanner.close();
			return;
		}
		
		printBig(v); // 벡터 v의 정수 중 가장 큰 수 출력
		scanner.close();
	}

}

 

 

2번

import java.util.*;

public class ArrayListScore {
	public static void main(String[] args) {
		ArrayList<Character> a = new ArrayList<Character>();
		Scanner scanner = new Scanner(System.in);

		System.out.print("6개의 학점을 빈 칸으로 분리 입력(A/B/C/D/F)>>");
		for(int i=0; i<6; i++) {
			String s = scanner.next();
			if(s.length() > 1) {
				System.out.println("Not character");
				scanner.close();
				return;
			}
			char ch = s.charAt(0);
			if((ch >= 'A' && ch <= 'D') || ch == 'F')
				a.add(ch);
			else {
				System.out.println("Invalid");
				scanner.close();
				return;
			}
		}
		
		double score=0.0;
		for(int i=0; i<a.size(); i++) {
			char ch = a.get(i);
			switch(ch) {
				case 'A' : score += 4.0; break;
				case 'B' : score += 3.0; break;
				case 'C' : score += 2.0; break;
				case 'D' : score += 1.0; break;
				case 'F' : score += 0.0; break;			
			}
		}
		
		System.out.print(score/a.size());
		scanner.close();
	}

}

 

주식하면 집안 망한다.

3번

import java.util.*;

public class HashMapNation {
	public static void main(String[] args) {
		HashMap<String, Integer> nations = new HashMap<String, Integer>();
		Scanner scanner = new Scanner(System.in);
		
		System.out.println("나라 이름과 인구를 10개 입력하세요.(예: Korea 5000)");
		while(true) { // "그만"이 입력될 때까지 반복
			System.out.print("나라 이름, 인구 >> ");		
			String nation = scanner.next();
			if(nation.equals("그만"))
				break; // 입력 끝
			int population = scanner.nextInt();
			nations.put(nation, population); // 해시맵 나라이름과 인수 저장
		}
		
		while(true) {
			System.out.print("인구 검색 >> ");
			String nation = scanner.next();
			if(nation.equals("그만"))
				break;
			Integer n = nations.get(nation);
			if(n == null)
				System.out.println(nation + " 나라는 없습니다.");
			else 
				System.out.println(nation + "의 인구는 " + n); 
		}
		
		scanner.close();
	}

}

 

4번

import java.util.*;

public class RainfallStatistics {
	
	public static void print(Vector<Integer> v) {
		int sum = 0;
		Iterator<Integer> it = v.iterator();
		while(it.hasNext()) {
			int n = it.next();
			System.out.print(n + " ");
			sum += n;
		}
		System.out.println();
		System.out.println("현재 평균 " + sum/v.size());		
		
	}

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		Vector<Integer> v = new Vector<Integer>();
		while(true) {
			System.out.print("강수량 입력 (0 입력시 종료)>> ");
			int n = scanner.nextInt();
			if(n == 0) 
				break;
			v.add(n);
			print(v);
		}
		
		scanner.close();
	}

}

 

 

5번

(1)

import java.util.*;

public class RainfallStatistics {
	
	public static void print(Vector<Integer> v) {
		int sum = 0;
		Iterator<Integer> it = v.iterator();
		while(it.hasNext()) {
			int n = it.next();
			System.out.print(n + " ");
			sum += n;
		}
		System.out.println();
		System.out.println("현재 평균 " + sum/v.size());		
		
	}

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		Vector<Integer> v = new Vector<Integer>();
		while(true) {
			System.out.print("강수량 입력 (0 입력시 종료)>> ");
			int n = scanner.nextInt();
			if(n == 0) 
				break;
			v.add(n);
			print(v);
		}
		
		scanner.close();
	}

}
import java.util.*;

public class StudentManager {
	private Scanner scanner = new Scanner(System.in);
	private ArrayList<Student> dept = new ArrayList<Student>();
	
	private void read() {
		System.out.println("학생 이름,학과,학번,학점평균 입력하세요.");
		for (int i=0; i<4; i++) {
			System.out.print(">> ");
			String text = scanner.nextLine();
			StringTokenizer st = new StringTokenizer(text, ",");
			String name = st.nextToken().trim();
			String department = st.nextToken().trim();
			String id = st.nextToken().trim();
			double grade = Double.parseDouble(st.nextToken().trim());
			
			Student student = new Student(name, department, id, grade);
			dept.add(student); // ArrayList에 저장
		}			
	}
	
	private void printAll() { // 일부러 Iterator로 작성해 보았음
		Iterator<Student> it = dept.iterator();
		while (it.hasNext()) {
			Student student = it.next();
			System.out.println("---------------------------");
			System.out.println("이름:" + student.getName());
			System.out.println("학과:" + student.getDepartment());
			System.out.println("학번:" + student.getId());
			System.out.println("학점평균:" + student.getGrade());
			System.out.println("---------------------------");
		}		
	}

	private void processQuery() {
		while(true) {
			System.out.print("학생 이름 >> ");
			String name = scanner.nextLine(); // 학생 이름 입력
			if(name.equals("그만"))
				return; // 종료
			
			for(int i=0; i<dept.size(); i++) { // dept에 있는 모든 학생 검색
				Student student = dept.get(i); // i번째 학생 객체
				if(student.getName().equals(name)) { //  이름이 같은 Student 찾음
					System.out.print(student.getName() + ", ");
					System.out.print(student.getDepartment() + ", ");
					System.out.print(student.getId() + ", ");
					System.out.println(student.getGrade());
					break; // for 문을 벗어남
				}
			} // end of while
		}
	}
	
	public void run() {
		read();
		printAll();
		processQuery();
	}
	
	public static void main (String[] args) {
		StudentManager man = new StudentManager();
		man.run();
	}
}

 

(2)

public class Student {
	private String name;
	private String department;
	private String id;
	private double grade;
	
	public Student(String name, String department, String id, double grade) {
		this.name = name;
		this.department = department;
		this.id = id;
		this.grade = grade;
	}
	public void setName(String name) { 
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setDepartment(String department) {
		this.department = department;
	}
	public String getDepartment() {
		return department;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getId() {
		return id;
	}
	public void setGrade(double grade) {
		this.grade = grade;
	}
	public double getGrade() {
		return grade;
	}
}
import java.util.*;

public class StudentManager {
	private Scanner scanner = new Scanner(System.in);
	private HashMap<String, Student> dept = new HashMap<String, Student>();
	
	private void read() {
		System.out.println("학생 이름,학과,학번,학점평균 입력하세요.");
		for (int i=0; i<4; i++) {
			System.out.print(">> ");
			String text = scanner.nextLine();
			StringTokenizer st = new StringTokenizer(text, ",");
			String name = st.nextToken().trim();
			String department = st.nextToken().trim();
			String id = st.nextToken().trim();
			double grade = Double.parseDouble(st.nextToken().trim());
			
			Student student = new Student(name, department, id, grade);
			dept.put(name, student); //해시맵에 저장
		}			
	}
	
	private void printAll() {
		Set<String> key = dept.keySet();
		Iterator<String> it = key.iterator();
		while (it.hasNext()) {
			String name = it.next(); // 이름 알아냄
			Student student = dept.get(name); // 이름을 키로하여 해시맵으로 Student 객체 얻어냄
			System.out.println("---------------------------");
			System.out.println("이름:" + student.getName());
			System.out.println("학과:" + student.getDepartment());
			System.out.println("학번:" + student.getId());
			System.out.println("학점평균:" + student.getGrade());
			System.out.println("---------------------------");
		}		
	}

	private void processQuery() {
		while(true) {
			System.out.print("학생 이름 >> ");
			String name = scanner.nextLine(); // 학생 이름 입력
			if(name.equals("그만"))
				return; // 종료
			
			Student student = dept.get(name); // 해시맵에서 이름을 키로 검색
			if(student == null) { // 이름이 해시맵에 없다면
				System.out.println(name + " 학생 없습니다.");
			}
			else { // 해시맵에서 검색된  Student 객체
				System.out.print(student.getName() + ", ");
				System.out.print(student.getDepartment() + ", ");
				System.out.print(student.getId() + ", ");
				System.out.println(student.getGrade());
			}
		}
	}
	
	public void run() {
		read();
		printAll();
		processQuery();
	}
	
	public static void main (String[] args) {
		StudentManager man = new StudentManager();
		man.run();
	}
}

 

6번

public class Location {
	private String city;
	private double longitude; // 경도
	private double latitude; // 위도
	
	public Location(String city, double longitude, double latitude) {
		this.city = city;
		this.longitude = longitude;
		this.latitude = latitude;
	}
	public void setCity(String city) { 
		this.city = city;
	}
	public String getCity() {
		return city;
	}
	public void setLogitude(double longitude) {
		this.longitude = longitude;
	}
	public double getLongitude() {
		return longitude;
	}
	public void setLatitude(double latitude) {
		this.latitude = latitude;
	}
	public double getLatitude() {
		return latitude;
	}
}
import java.util.*;

public class LocationManager {
	private Scanner scanner = new Scanner(System.in);
	private HashMap<String, Location> dept = new HashMap<String, Location>();
	
	private void read() {
		System.out.println("도시,경도,위도를 입력하세요.");
		for (int i=0; i<4; i++) {
			System.out.print(">> ");
			String text = scanner.nextLine();
			StringTokenizer st = new StringTokenizer(text, ",");
			String city = st.nextToken().trim();
			double logitude = Double.parseDouble(st.nextToken().trim());
			double latitude = Double.parseDouble(st.nextToken().trim());
			
			Location loc = new Location(city, logitude, latitude);
			dept.put(city, loc); //해시맵에 저장
		}			
	}
	
	private void printAll() {
		Set<String> key = dept.keySet();
		Iterator<String> it = key.iterator();
		System.out.println("---------------------------");
		while (it.hasNext()) {
			String city = it.next(); // 도시 이름 알아냄
			Location loc = dept.get(city); // 도시 이름을 키로하여 해시맵에서 Locaiton 객체 얻어냄

			System.out.print(loc.getCity() + "\t");
			System.out.print(loc.getLongitude() + "\t");
			System.out.println(loc.getLatitude());
		}
		System.out.println("---------------------------");		
	}

	private void processQuery() {
		while(true) {
			System.out.print("도시 이름 >> ");
			String city = scanner.nextLine(); // 도시 이름 입력
			if(city.equals("그만"))
				return; // 종료
			
			Location loc = dept.get(city); // 해시맵에서 도시를 키로 검색
			if(loc == null) { // 도시가 해시맵에 없다면
				System.out.println(city + "는 없습니다.");
			}
			else { // 해시맵에서 검색된  Student 객체
				System.out.print(loc.getCity()  + "\t");
				System.out.print(loc.getLongitude() + "\t");
				System.out.println(loc.getLatitude());
			}
		}
	}
	
	public void run() {
		read();
		printAll();
		processQuery();
	}
	
	public static void main (String[] args) {
		LocationManager man = new LocationManager();
		man.run();
	}
}

 

7번

import java.util.*;

class Scholarship {
	private String title;
	private Scanner scanner = new Scanner(System.in);
	private HashMap<String, Double> scoreMap = new HashMap<String, Double>();
	
	public Scholarship(String name) {
		this.title = name;
	}
	public void read() {
		System.out.println(title + "관리시스템입니다.");
		for(int i=0; i<5; i++) {
			System.out.print("이름과 학점>> ");
			String name = scanner.next();
			double score = scanner.nextDouble();
			scoreMap.put(name,  score);
		}		
	}
	
	public void select() {
		System.out.print("장학생 선발 학점 기준 입력>> ");
		double cutline = scanner.nextDouble();
		
		System.out.print("장학생 명단 : ");
		Set<String> nameSet = scoreMap.keySet();
		Iterator<String> it = nameSet.iterator();
		while(it.hasNext()) {
			String name = it.next();
			double score = scoreMap.get(name);
			if(score > cutline)
				System.out.print(name + " ");
		}
		System.out.println();
	}
	
	public static void main(String [] args) {
		Scholarship sship = new Scholarship("미래장학금");
		sship.read();
		sship.select();
	}
}

 

8번

import java.util.*;

public class CustomerManager {
	private HashMap<String, Integer> map = new HashMap<String, Integer>();
	private Scanner scanner = new Scanner(System.in);
	
	public CustomerManager() { }
	
	public void run() {
		System.out.println("** 포인트 관리 프로그램입니다 **");

		while(true) {
			System.out.print("이름과 포인트 입력>> ");
			String name = scanner.next();
			if(name.equals("그만"))
				break;
			int point = scanner.nextInt();
			
			Integer n = map.get(name); // 이름으로 포인트 검색
			if(n != null) { // 신규가 아닌 경우
				point += n; // 포인트 점수 누적
			}
			
			map.put(name, point); // 이름과 누적 포인트 갱신
			printAll();
		}
	}
	
	void printAll() {
		Set<String> keys = map.keySet();
		Iterator<String> it = keys.iterator();
		while(it.hasNext()) {
			String name = it.next();
			int point = map.get(name);
			System.out.print("("+name+","+point+")");			
		}
		System.out.println();
	}
	
	public static void main(String[] args) {
		CustomerManager man = new CustomerManager();
		man.run();
	}
}

 

9번

public interface IStack<T> {
	public T pop();
	public boolean push(T ob);
}
import java.util.ArrayList;

// MyStack은 push() 새로 추가되는 아이템을 항상 맨 앞에 삽입한다.
// 그러므로 pop() 역시 맨 앞에 있는 아이템을 삭제한다. 
public class MyStack<T> implements IStack<T> {
	ArrayList<T> l = null;
	public MyStack() {
		l = new ArrayList<T>();
	}

	@Override
	public T pop() {
		if (l.size() == 0)
			return null; 
		else {
			return l.remove(0); // 맨 앞에 있는 아이템 삭제
		}
	}

	@Override
	public boolean push(T ob) {
		l.add(0, ob); // 맨 끝에 삽입 
		return true;
	}
}
public class StackManager {
	
	public static void main (String[] args) {
		IStack<Integer> stack = new MyStack<Integer>();
		for (int i=0; i<10; i++) stack.push(i); // 10개의 정수 푸시
		while (true) { // 스택이 빌 때까지 pop
			Integer n = stack.pop();
			if(n == null) break; // 스택이 빈 경우
			System.out.print(n + " ");
		}
	}
	
}

 

10번

public abstract class Shape {
	private Shape next;
	public Shape() { next = null;}
	public void setNext(Shape obj) {next = obj;} // 링크 연결
	public Shape getNext() {return next;}
	public abstract void draw();
}
public class Line extends Shape {
	
	@Override
	public void draw() {
		 System.out.println("Line");
	}
}
public class Rect extends Shape {

	@Override
	public void draw() {
		 System.out.println("Rect");
	}

}
public class Circle extends Shape {
	
	@Override
	public void draw() {
		 System.out.println("Circle");
	}

}
import java.util.Scanner;
import java.util.Vector;

public class GraphicEditor {
	private String editorName;
	private Scanner scanner = new Scanner(System.in);
	private Vector<Shape> v = new Vector<Shape>();
	
	public GraphicEditor(String editorName) {
		this.editorName = editorName;
	}
	
	public void run() {
		System.out.println("그래픽 에디터 " + editorName + "을 실행합니다.");
		int choice = 0;
		while (choice != 4) { 
			int type, index;
			System.out.print("삽입(1), 삭제(2), 모두 보기(3), 종료(4)>>");
			choice = scanner.nextInt();
			switch (choice) {
				case 1:	// 삽입
					System.out.print("Line(1), Rect(2), Circle(3)>>");
					type = scanner.nextInt();
					if (type < 1 || type > 3) {
						System.out.println("잘못 선택하셨습니다.");
						break;
					}
					insert(type);
					break;
				case 2:	// 삭제
					System.out.print("삭제할 도형의 위치>>");
					index = scanner.nextInt();
					if (!delete(index)) {
						System.out.println("삭제할 수 없습니다.");
					}
					break;
				case 3:	// 모두 보기
					view();
					break;
				case 4:	// 끝내기
					break;
				default:
					System.out.println("잘못 입력하셨습니다.");
			}
		}
		System.out.println(editorName + "을 종료합니다.");	
	}

	private void view() {
		for(int i=0; i<v.size(); i++) v.get(i).draw();
	}
	
	private boolean delete(int index) {
		if (v.size() == 0 || index >= v.size()) // 리스트가 비거나, 인덱스에 도형이 없는 경우
			return false;
		v.remove(index);
		return true;
	}

	private void insert(int choice) {
		Shape shape=null;
		switch (choice) {
			case 1: // Line
				shape = new Line();
				 break;
			case 2: // Rect
				shape = new Rect();
				break;
			case 3: // Circle
				shape = new Circle();
		}
		v.add(shape);
	}
	
	public static void main(String [] args) {
		GraphicEditor ge = new GraphicEditor("beauty");
		ge.run();
	}
}

 

11번

(1)

public class Nation {
	private String country;
	private String capital;
	
	public Nation(String country, String capital) {
		this.country = country;
		this.capital = capital;
	}
	
	public String getCountry() {
		return country;
	}
	
	public String getCapital() {
		return capital;
	}
}
import java.util.Scanner;
import java.util.Vector;

public class CapitalGame {
	private Vector<Nation> store = new Vector<Nation>();
	private Scanner scanner = new Scanner(System.in);
	
	public CapitalGame() {
		// store에 9 개의 아이템을 입력하여 초기화
		store.add(new Nation("멕시코", "멕시코시티"));
		store.add(new Nation("스페인", "리스본"));
		store.add(new Nation("프랑스", "파리"));
		store.add(new Nation("영국", "런던"));
		store.add(new Nation("그리스", "아테네"));
		store.add(new Nation("독일", "베를린"));
		store.add(new Nation("일본", "동경"));
		store.add(new Nation("중국", "베이찡"));
		store.add(new Nation("러시아", "모스크바"));
	}
	
	private void error(String msg) {
		System.out.println(msg);
	}
	
	public void run() {
		System.out.println("**** 수도 맞추기 게임을 시작합니다. ****");
		while(true) {
			System.out.print("입력:1, 퀴즈:2, 종료:3>> ");
			int menu = scanner.nextInt();
			switch(menu) {
				case 1: input(); break;
				case 2: quiz(); break;
				case 3: finish(); return;
				default: 
					error("잘못된 입력입니다.");
			}
		}
		
	}

	private boolean contains(String country) {
		for(int i=0; i<store.size(); i++) {
			if(store.get(i).getCountry().equals(country)) { // 사용자가 입력한 나라가 이미 있다면
				return true;
			}
		}
		
		return false;

	}
	private void input() {
		int n = store.size();
		System.out.println("현재 " + n + "개 나라와 수도가 입력되어 있습니다.");
		n++;
		while(true) {
			System.out.print("나라와 수도 입력" + n + ">> ");
			String country = scanner.next(); // 사용자 입력 나라
			if(country.equals("그만")) {
				break;
			}
			String capital = scanner.next(); // 사용자 입력, 수도

			if(contains(country)) { // 사용자가 입력한 나라가 이미 있다면
				System.out.println(country + "는 이미 있습니다!");
				continue;
			}
				
			store.add(new Nation(country, capital));
			n++;
		}
	}

	private void quiz() {
		// 모든 키(나라)를 알아낸다.
		while(true) {
			// 나라 중에서 하나를 선택한다.
			int index = (int)(Math.random()*store.size()); // 랜덤한 위치 결정
			
			// 문제(나라)와 정답(수도)을 결정한다.
			Nation nation = store.get(index);
			String question = nation.getCountry();
			String answer = nation.getCapital();
			
			// 문제를 출력한다.
			System.out.print(question + "의 수도는? ");
			
			String capitalFromUser = scanner.next(); // 사용자의 입력
			if(capitalFromUser.equals("그만")) {
				break;
			}
			if(capitalFromUser.equals(answer))
				System.out.println("정답!!");
			else
				System.out.println("아닙니다!!");				
		}	
		
	}

	private void finish() {
		System.out.println("게임을 종료합니다.");	
	}

	public static void main(String[] args) {
		CapitalGame game = new CapitalGame();
		game.run();

	}

}

(2)

import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;

public class CapitalGame {
	private HashMap<String, String> store = new HashMap<String, String>();
	private Scanner scanner = new Scanner(System.in);
	
	public CapitalGame() {
		// store에 9 개의 아이템을 입력하여 초기화
		store.put("멕시코", "멕시코시티");
		store.put("스페인", "리스본");
		store.put("프랑스", "파리");
		store.put("영국", "런던");
		store.put("그리스", "아테네");
		store.put("독일", "베를린");
		store.put("일본", "동경");
		store.put("중국", "베이찡");
		store.put("러시아", "모스크바");
	}
	
	private void error(String msg) {
		System.out.println(msg);
	}
	
	public void run() {
		System.out.println("**** 수도 맞추기 게임을 시작합니다. ****");
		while(true) {
			System.out.print("입력:1, 퀴즈:2, 종료:3>> ");
			int menu = scanner.nextInt();
			switch(menu) {
				case 1: input(); break;
				case 2: quiz(); break;
				case 3: finish(); return;
				default: 
					error("잘못된 입력입니다.");
			}
		}
		
	}
	
	private void input() {
		int n = store.size();
		System.out.println("현재 " + n + "개 나라와 수도가 입력되어 있습니다.");
		n++;
		while(true) {
			System.out.print("나라와 수도 입력" + n + ">> ");
			String country = scanner.next();
			if(country.equals("그만")) {
				break;
			}
			String capital = scanner.next();
			if(store.containsKey(country)) {
				System.out.println(country + "는 이미 있습니다");
				continue;
			}
			store.put(country, capital);
			n++;
		}
	}

	private void quiz() {
		// 모든 키(나라)를 알아낸다.
		Set<String> keys = store.keySet();
		Object [] array = (keys.toArray());
		while(true) {
			// 나라 중에서 하나를 선택한다.
			int index = (int)(Math.random()*array.length); // 랜덤한 위치 결정
			
			// 문제(나라)와 정답(수도)을 결정한다. 
			String question = (String)array[index];
			String answer = store.get(question);
			
			// 문제를 출력한다.
			System.out.print(question + "의 수도는? ");
			
			String capitalFromUser = scanner.next(); // 사용자의 입력
			if(capitalFromUser.equals("그만")) {
				break;
			}
			if(capitalFromUser.equals(answer))
				System.out.println("정답!!");
			else
				System.out.println("아닙니다!!");				
		}	
		
	}

	private void finish() {
		System.out.println("게임을 종료합니다.");	
	}

	public static void main(String[] args) {
		CapitalGame game = new CapitalGame();
		game.run();

	}

}

12번

import java.util.InputMismatchException;
import java.util.Scanner;
import java.util.Vector;

class Word { // 영어 단어와 한글 단어를 쌍으로 가진 하나의 단어 표현
	private String english; // 영어 단어
	private String korean; // 영어 단어에 해당하는 한글 단어
	public Word(String english, String korean) {
		this.english = english;
		this.korean = korean;
	}
	public String getEnglish() { return english; }
	public String getKorean() { return korean; }
	
}
public class WordQuiz {
	private String name; // WordQuiz 프로그램의 이름
	private Scanner scanner = new Scanner(System.in);
	private Vector<Word> v;

	public WordQuiz(String name) {
		this.name = name;
		v = new Vector<Word>();
		v.add(new Word("love", "사랑"));
		v.add(new Word("animal", "동물"));
		v.add(new Word("emotion", "감정"));
		v.add(new Word("human", "인간"));
		v.add(new Word("stock", "주식"));
		v.add(new Word("trade", "거래"));
		v.add(new Word("society", "사회"));
		v.add(new Word("baby", "아기"));
		v.add(new Word("honey", "애인"));
		v.add(new Word("dall", "인형"));
		v.add(new Word("bear", "곰"));
		v.add(new Word("picture", "사진"));
		v.add(new Word("painting", "그림"));
		v.add(new Word("fault", "오류"));
		v.add(new Word("example", "보기"));
		v.add(new Word("eye", "눈"));
		v.add(new Word("statue", "조각상"));
	}
	
	// ex[] 배열에 4개의 보기를 만든다. 보기는 현재 단어 벡터에 있는 단어를 랜덤하게 4개를 선택하고, 벡터에 대한 인덱스를
	// ex[] 배열에 저장한다.
	// answerIndex는 정답이 있는 벡터의 인덱스이므로, ex []에는 answerIndex 값이 들어가지 않도록 한다.
	// 그러므로 이 메소드가 리턴할 때는 answerIndex가 없는 ex[] 배열이 만들어지며, ex[] 배열에 대한 임의의 인덱스틀
	// 리턴한다. 이 메소드가 끝난 뒤 이 위치에 answerIndex를 심는다. 
	private int makeExample(int ex[], int answerIndex) {
		int n[] = {-1, -1, -1, -1}; // -1로 초기화
		int index;
		for(int i=0; i<n.length; i++) {
			do {
				index = (int)(Math.random()*v.size());
			} while(index == answerIndex || exists(n, index)); // 다시 시도
			n[i] = index;
		}

		for(int i=0; i<n.length; i++) ex[i] = n[i];
		return (int)(Math.random()*n.length); // ex[] 배열 내의 임의의 위치 리턴. 이곳에 정답을 심는다.
	}
	
	// 배열 n[]에 index의 값이 존재하면 true, 아니면 false 리턴
	private boolean exists(int n[], int index) {
		for(int i=0; i<n.length; i++) {
			if(n[i] == index)
				return true;
		}
		return false;
	}
	
	public void run() {
		System.out.println("**** 영어 단어 테스트 프로그램 \"" + name + "\" 입니다. ****"); 
		while(true) {
			System.out.print("단어 테스트:1, 단어 삽입:2. 종료:3>> ");
			try {
				int menu = scanner.nextInt();
				switch(menu) {
					case 1: wordQuiz(); break;					
					case 2: insertWords(); break;
					case 3: finish(); return;
					default :
						System.out.println("잘못 입력하였습니다.");
				}
			}
			catch(InputMismatchException e) { // 사용자가 정수가 아닌 문자나 실수를 입력한 경우 예외 처리
				scanner.next(); // 현재 스트림 버퍼에 입력되어 있는 입력을 읽어서 제거함
				System.out.println("숫자를 입력하세요 !!");
				// 다시 while 문으로 반복
			}
			System.out.println(); // 빈 줄 한 줄 출력
		}
	}

	private void insertWords() {
		System.out.println("영어 단어에 그만을 입력하면 입력을 종료합니다.");
		while(true) {
			System.out.print("영어 한글 입력 >> ");
			String engWord = scanner.next(); // 영어 단어 읽기
			if(engWord.equals("그만"))
				break;
			
			String korWord = scanner.next(); // 한글 단어 읽기
			v.add(new Word(engWord, korWord));
		}		
	}

	private void finish() {
		System.out.println("\"" + name + "\"를 종료합니다.");
		scanner.close();
	}
		
	private void wordQuiz() {
		System.out.println("현재 " + v.size() + "개의 단어가 들어 있습니다. -1을 입력하면 테스트를 종료합니다.");
		while(true) { 
			int answerIndex = (int)(Math.random()*v.size()); // 정답이 들어 있는 벡터 항목의 인덱스
			String eng = v.get(answerIndex).getEnglish(); // 문제로 주어질 영어 단어
			
			// 4개의 보기를 만들 벡터의 index 배열
			int example[] = new int [4];
			
			int answerLoc = makeExample(example, answerIndex); // 정답이 있는 보기 번호
			example[answerLoc] = answerIndex; // 보기에 정답 인덱스 저장

			// 문제를 출력합니다.
			System.out.println(eng + "?");
			
			// 보기 모두 출력
			for(int i=0; i<example.length; i++)
				System.out.print("(" + (i+1) + ")" + v.get(example[i]).getKorean() + " "); // 보기 출력
			
			
			// 정답을 입력받을 프롬프트 출력
			System.out.print(":>"); // 프롬프트
			try {
				int in = scanner.nextInt(); // 사용자의 정답 입력
				if(in == -1) 
					break; //단어 테스트를 끝내고자 하는 경우
				
				in--; // 입력된 정수(1~4)에 	1을 빼서 0으로부터 시작하는 인덱스로 바꿈
				if(in == answerLoc)
					System.out.println("Excellent !!");
				else
					System.out.println("No. !!");
			}
			catch(InputMismatchException e) {
				scanner.next(); // 현재 스트림 버퍼에 입력되어 있는 입력을 읽어서 제거함
				System.out.println("숫자를 입력하세요 !!");
				// 다시 while 문으로 반복
			}
		}		
	}
	
	public static void main(String[] args) {
		WordQuiz quiz = new WordQuiz("명품영어");
		quiz.run();
	}

}

 

13번

import java.util.StringTokenizer;

public class Instruction {
	private String line;
	private String opcode;
	private String operand [] = new String [2];
	public Instruction(String line) {
		this.line = line;
		line = line.toUpperCase(); // 대문자로 만들기
		StringTokenizer st = new StringTokenizer(line);
		// line이 "ADD S J"
		opcode = st.nextToken(); // 첫 토큰, 명령, "ADD"
		operand[0] = st.nextToken(); // "S"
		operand[1] = st.nextToken(); // "J"
	}
	
	public String getOpcode() {
		return opcode;
	}
	
	public String getOperand(int index) {
		if(index < 0 || index > 2)
			return null;
		return operand[index];
	}
	
	public String toString() {
		return "[" + line + "] ";
	}
}
import java.util.HashMap;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;
import java.util.Vector;

public class Machine {
	private String name;
	private HashMap<String, Integer> memory = new HashMap<String, Integer>();
	private Vector<Instruction> program = new Vector<Instruction>();
	private Scanner scanner = new Scanner(System.in);
	
	public Machine(String name) {
		this.name = name;
	}
	
	public void readProgramIntoMemory() {
		while(true) {
			System.out.print(">> ");
			String line = scanner.nextLine();
			if(line.toUpperCase().equals("GO"))
				break;
			program.add(new Instruction(line));
		}
	}
	public void clearMemory() {
		program.removeAllElements(); // 벡터의 모든 요소 삭제
		memory.clear();
	}
	
	public void error(int pc, String msg) {
		System.out.print("프로그램 라인 " + (pc+1) + "에서 오류. " + msg);
	}
	
	public void execute() {
		int pc=0;
		while(true) {
			Instruction instruction = program.get(pc);
			pc++; // 미리 다음 명령의 주소로 설정
			switch(instruction.getOpcode()) {
				case "MOV" : mov(instruction); break;
				case "ADD" : add(instruction); break;				
				case "SUB" : sub(instruction); break;
				case "JN0" : 
					int newAddr = jn0(instruction);
					if(newAddr == -1) // no jump
						break; // break from switch
					else {
						pc = newAddr;
						break;
					}				
				case "PRT" : prt(instruction); return;
				default : 	error(instruction); return;
			}

			// printVariables(instruction); // 이 메소드를 실행하면 실행 중에 변하는 변수 모두 볼 수 있음
		}
	}
	
	private void error(Instruction instruction) {
		System.out.print("명령 오류! ");
		printVariables(instruction);
	}
	
	private void printVariables(Instruction instruction) {
		System.out.print(instruction+"\n");
		
		Set<String> s = memory.keySet();
		Iterator<String> it = s.iterator();
		while(it.hasNext()) {
			String variable = it.next();
			int value = memory.get(variable);
			System.out.print(variable + ":" + value + "\t");
		}
		System.out.println();
	}
	
	private void prt(Instruction instruction) { // 첫번째 피연산자 값을 출력하고 종료. 두번째 피연산자는 의미없음
		String first = instruction.getOperand(0);
		
		int n = getValue(first);
		printVariables(instruction); 
		System.out.println("출력할 결과는 " + n + ". 프로그램 실행 끝");
	}

	private int jn0(Instruction instruction) { // 첫번째 피연산자가 0이 아니면 두번째 피연산자의 주소로 점프
		String first = instruction.getOperand(0);
		String second = instruction.getOperand(1);
		
		int n = getValue(first);
		int m = getValue(second);
		if(n != 0) { // n이 0이 아니면
			return m; // 점프할 주소
		}
		else
			return -1; // 점프 없이 다음으로 진행
	}
	
	private void sub(Instruction instruction) {
		String first = instruction.getOperand(0);
		String second = instruction.getOperand(1);
		
		int n = getValue(first);
		int m = getValue(second);
		memory.put(first, n-m);
	}

	private void add(Instruction instruction) {
		String first = instruction.getOperand(0);
		String second = instruction.getOperand(1);
		
		int n = getValue(first);
		int m = getValue(second);
		memory.put(first, n+m);
	}
	
	private void mov(Instruction instruction) {
		String variable = instruction.getOperand(0); // 첫번째 변수
		String second = instruction.getOperand(1); // 두번
		
		int n = getValue(second);
		memory.put(variable, n); // 첫번째 변수에 값 저장
	}
	
	private int getValue(String opr) { // opr이 정수이면 수로 리턴. 변수명이면 변수명의 값 리턴.없는 변수이면 새로만들고 0리턴
		int n;
		try {
			n = Integer.parseInt(opr); // opr 피연산자가 정수인 경우
		}
		catch(NumberFormatException e) { // opr 피연산자가 변수인 경우
			Integer value = memory.get(opr); // 변수 값 알아내기
			if(value == null) { // opr 이름의 변수가 없다면
				memory.put(opr, 0); // opr의 값을 0으로 하여 새 변수 생성
				n = 0; // 초기 값 0
			}
			else {
				n = value; // opr 변수의 저장 값
			}
		}
		return n;
	}

	public void run() {
		System.out.println(name + "이 작동합니다. 프로그램을 입력해주세요. GO를 입력하면 작동합니다.");
		while(true) {
			readProgramIntoMemory(); // "GO" 가 입력될 때까지 읽기
			execute();
			clearMemory();
		}
	}
	
	public static void main(String[] args) {
		Machine m = new Machine("수퍼컴");
		m.run();
	}

}

 

삼성전자 직급별 연봉, 이렇게나 많이 받아???