고퍼

ㅎㅎ

G0pher — Tue, 24 Aug 2021 12:53:13 +0900

레츠고! 주피터

G0pher — Tue, 5 May 2020 09:54:31 +0900

ㄱㄱ

tesseract.js

G0pher — Fri, 1 May 2020 17:24:37 +0900

tesseract.js-chrome-extension-master.z01

10.00MB

tesseract.js-chrome-extension-master.zip

1.73MB

ocrad.js

G0pher — Fri, 1 May 2020 16:29:08 +0900

ocrad.js

3.06MB

ocrad.js

cleanweb

G0pher — Wed, 1 Apr 2020 05:55:27 +0900

cleanweb

Cleanweb.zip

0.04MB

ip2020-03

G0pher — Sun, 15 Mar 2020 20:13:28 +0900

2020-03.xls

2.98MB

다운로드

h65

G0pher — Mon, 19 Aug 2019 15:11:02 +0900

칼리 리눅스 한글 패치

G0pher — Thu, 27 Sep 2018 20:32:24 +0900

칼리 리눅스를 설치했는데 한글패치가 안되어있어서

화면에 이상한 문자들만 가득했다.

다음과 같이 한글패치를 진행해보자

1
vi /etc/apt/sources.list
cs

위와같이 vi 에디터로 sources.list 파일을 열어 아래의 문장을 추가해서 apt로 가져올 수 있는 사이트를 추가해보자

1
deb http://httpredir.debian.org/debian jessie main non-free contrib
cs

위의 문장을 입력했다면 아래의 명령들을 입력하자

1
2
3
apt-get update
apt-get install nabi im-switch
apt-get install fonts-nanum*
cs

위와 같이 입력해서 한글패치를 마치자

Java :: 피자 주문 프로그램

G0pher — Thu, 27 Sep 2018 20:22:00 +0900

피자 메뉴를 입력받고, 여러 주문을 입력받아 주문 내역과 가동률을 구하는 프로그램

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
import java.util.Scanner;
import java.util.ArrayList;
 
/**
 * 
 * 객체 지향에 대해서 어느정도 이해했다고 생각했는데
 * 이번 문제 풀면서 또 많은것을 느낀것 같습니다.
 * 최대한 메소드 길이를 비슷하게 맞춰보려고 노력했으나 역시 쉽지가 않네요
 * 부족한 부분 최대한 피드백 많이 해주시면
 * 고쳐보겠습니다!!
 * 
 * @author LeeJaeSeung (g0pher)
 */
public class PizzaDemo {
    ArrayList<Pizza> pizza = new ArrayList<Pizza>();
    ArrayList<Order> order = new ArrayList<Order>();
    
    double lastServing = 1.0;
    
    public static void main(String [] args) {
        PizzaDemo start = new PizzaDemo();
        start.doit();
    }
    void doit() {
        Scanner sc = new Scanner(System.in);
        inputPizza(sc);
        inputOrder(sc);
        process();
        printInfo();
        printResult();
    }
    void inputPizza(Scanner sc) {
        while (true) {
            int number = sc.nextInt();
            if (number == 0) { break; }
            pizza.add(new Pizza(number, sc));
        }
    }
    void inputOrder(Scanner sc) {
        while (true) {
            int number = sc.nextInt();
            if (number == 0) { break; }
            order.add(new Order(number, sc));
        }
    }
    void process() {
        for (Order i: order) {
            pizza.get(i.pizzaNum - 1).order(i);
            if (lastServing < i.servingTime) {
                lastServing = i.servingTime;
            }
        }
    }
    void printInfo() {
        System.out.println("  ====== 메뉴판 ======");
        for (Pizza i: pizza) { i.print(); }
        System.out.printf("\n\n%15s %10s %10s %10s\n", "주문리스트", "주문", "요리시작", "서빙");
        for (Order i: order) {
            String pizzaName = pizza.get(i.pizzaNum - 1).name;
            i.print(pizzaName);
        }
    }
    void printResult() {
        System.out.println("\n  ====== 오븐 요리 현황 ======");
        for (Pizza i: pizza) {
            System.out.printf("%s (요리시간 %d분)\n", i.name, i.time);
            for (Order j: i.o) {
                System.out.printf("[%d] %d분주문 %d~%d (%d분대기)\n"
                        ,j.number, j.orderTime, j.startTime
                        , j.servingTime, j.servingTime - j.orderTime);
            }
            double operatingRate = (i.o.size() * i.time / lastServing) * 100;
            System.out.println(lastServing);
            System.out.printf("%d개 완료 (평균 %.1f분 대기) [가동율 %.1f%%]\n\n"
                    , i.o.size(), i.average(), operatingRate);
        }
    }
}
 
class Pizza {
    int number;
    String name;
    int time;
    ArrayList<Order> o = new ArrayList<Order>();
    
    Pizza(int number, Scanner sc) {
        this.number = number;
        name = sc.next();
        time = sc.nextInt();
    }
    void order(Order order) {
        o.add(order);
        if (o.size() > 1) {
            Order prev = o.get(o.size() - 2);
            if (prev.servingTime > order.orderTime) {
                order.startTime = prev.servingTime;
            }    
        }
        order.servingTime = order.startTime + time;
    }
    void print() {
        System.out.printf("%-10s (요리시간 %d분)\n", name, time);
    }
    double average() {
        int sum = 0;
        if (o.size() == 0) { return 0.0; }
        for (Order i: o) {
            sum += i.servingTime - i.orderTime;
        }
        return (double)sum / o.size();
    }
}
 
class Order {
    int number;
    int orderTime;
    int pizzaNum;
    int startTime;
    int servingTime;
    
    Order(int number, Scanner sc) {
        this.number = number;
        orderTime = startTime = sc.nextInt();
        pizzaNum = sc.nextInt();
    }
    void print(String pizzaName) {
        System.out.printf("[%d] %-10s %2d분 -- %2d분 -- %2d분\n"
                ,number, pizzaName, orderTime, startTime, servingTime);
    }
}
Colored by Color Scripter
cs

Java :: 적은 비용의 계단 구하기

G0pher — Thu, 27 Sep 2018 20:19:47 +0900

각 계단마다 가격이 존재하고 마지막 계단을 밟기까지 최소 비용의 방법을 구하는 프로그램.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
import java.util.Scanner;
 
/**
 * 
 * 조건을 맞추려고 노력 많이 했습니다!
 * 객체지향 코딩에 대한 이해가 전보다는 나아진것 같습니다.
 * 부족한 부분은 피드백 주세요!!
 * 
 * @author LeeJaeSeung (g0pher)
 */
public class StairDemo {
    public static void main(String [] args) {
        StairDemo start = new StairDemo();
        start.doit();
    }
    void doit() {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        Step [] stairs = new Step[N];
        for (int i = 0; i < 3; i++) {
            stairs[i] = new Step(i+1, sc.nextInt());
        }
        for (int i = 3; i < N; i++) {
            stairs[i] = new Step(i+1, sc.nextInt());
            stairs[i].compute(stairs[i-1], stairs[i-2], stairs[i-3]);
        }
        stairs[N-1].print();
    }
}
 
class Step {
    int number;
    int cost;
    int minToHere;
    Step prev = null;
    Step (int number, int cost) {
        this.number = number;
        this.cost = cost;
        minToHere = cost;
    }
    void compute(Step s1, Step s2, Step s3) {
        if (s1.compareTo(s2) == 1) {
            if (s2.compareTo(s3) == 1) { prev = s3; }
            else { prev = s2; }
        }
        else {
            if (s1.compareTo(s3) == 1) { prev = s3; }
            else { prev = s1; }
        }
        minToHere = prev.minToHere + cost;
    }
    void print() {
        if (prev != null) {
            prev.print();
        }
        System.out.printf("[%2d] %d %d\n", number, cost, minToHere);
    }
    int compareTo(Step s) {
        if (minToHere < s.minToHere) { return 0; }
        return 1;
    }
}
Colored by Color Scripter
cs