트럭 - ACM 2016 문제 중에서

출처 강을 가로지르는 하나의 차선으로 된 다리가 하나 있다. 이 다리를 n 개의 트럭이 건너가려고 한다. 트럭의 순서는 바꿀 수 없으며, 트럭의 무게는 서로 같지 않을 수 있다. 다리 위에는 단지 w 대의 트럭만 동시에 올라갈 수 있다. 다리의 길이는 w 단위길이(unit distance)이며, 각 트럭들은 하나의 단위시간(unit time)에 하나의 단위길이만큼만 이동할 수 있다고 가정한다. 동시에 다리 위에 올라가 있는 트럭들의 무게의 합은 다리의 최대하중인 L보다 작거나 같아야 한다. 참고로, 다리 위에 완전히 올라가지 못한 트럭의 무게는 다리 위의 트럭들의 무게의 합을 계산할 때 포함하지 않는다고 가정한다.

예를 들어, 다리의 길이 w는 2, 다리의 최대하중 L은 10, 다리를 건너려는 트럭이 트럭의 무게가 [7, 4, 5, 6]인 순서대로 다리를 오른쪽에서 왼쪽으로 건넌다고 하자. 이 경우 모든 트럭이 다리를 건너는 최단시간은 아래의 그림에서 보는 것과 같이 8 이다.
다리건너기 과정

다리의 길이와 다리의 최대하중, 그리고 다리를 건너려는 트럭들의 무게가 순서대로 주어졌을 때, 모든 트럭이 다리를 건너는 최단시간을 구하는 프로그램을 작성하라.

입력
입력 데이터는 표준입력을 사용한다. 입력은 두 줄로 이루어진다. 입력의 첫 번째 줄에는 세 개의 정수 n (1 ≤ n ≤ 1,000) , w (1 ≤ w ≤ 100) and L (10 ≤ L ≤ 1,000)이 주어지는데, n은 다리를 건너는 트럭의 수, w는 다리의 길이, 그리고 L은 다리의 최대하중을 나타낸다. 입력의 두 번째 줄에는 n개의 정수 a1, a2, ⋯ , an (1 ≤ ai ≤ 10)가 주어지는데, ai는 i번째 트럭의 무게를 나타낸다.

출력
출력은 표준출력을 사용한다. 모든 트럭들이 다리를 건너는 최단시간을 출력하라.

샘플 1.

4 2 10
7 4 5 6
8

샘플 2.

1 100 100
10
101

샘플 3.

10 100 100
10 10 10 10 10 10 10 10 10 10
110
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

20개의 풀이가 있습니다. 1 / 2 Page

다리로 이용할 리스트(길이가 w 이고 0으로 가득찬)를 준비해서 큐로 사용합니다. 다리의 내용을 한 칸 밀고, 남은 무게의 합과 대기열 중 가장 앞 트럭의 무게를 더해서 안전한 수준이면 다리 뒤에 추가합니다. 그렇지 않으면 0을 추가합니다. 대기열에 트럭이 없는 경우에도 다리는 0을 밀어넣습니다.

이런식으로 트럭대기열이 비고, 다리위에 트럭이 없을 때까지 반복해서 몇 번 반복했는지 카운트를 세면 됩니다.

(수정)

다리를 못 건너는 트럭이 있을 수 있어서 체크하는 로직을 추가했습니다. 더불어 각 틱마다 트럭의 위치를 표시하게끔 했습니다.

def do():

    n, w, l = [int(x) for x in input().split()][:3]
    xs = [int(x) for x in input().split()][:n]
    if max(xs) > l:
        print("can't cross the bridge.")
    bridge = [0] * w
    elapsed = 0

    def show():
        print(
            elapsed,
            '({:02d})'.format(sum(bridge)),
            ''.join('[{}]'.format(x if x > 0 else '_') for x in bridge),
            xs
        )

    show()
    while xs or sum(bridge) > 0:
        x = xs[0] if xs else 0
        if sum(bridge[1:]) + x <= l:
            bridge = bridge[1:] + [x]
            xs = xs[1:]
        else:
            bridge = bridge[1:] + [0]
        elapsed += 1
        show()
    return elapsed

print(do())

아래는 결과입니다

8 4 12
4 2 5 8 6 2 4 9
(00) (00) [_][_][_][_] [4, 2, 5, 8, 6, 2, 4, 9]
(01) (04) [_][_][_][4] [2, 5, 8, 6, 2, 4, 9]
(02) (06) [_][_][4][2] [5, 8, 6, 2, 4, 9]
(03) (11) [_][4][2][5] [8, 6, 2, 4, 9]
(04) (11) [4][2][5][_] [8, 6, 2, 4, 9]
(05) (07) [2][5][_][_] [8, 6, 2, 4, 9]
(06) (05) [5][_][_][_] [8, 6, 2, 4, 9]
(07) (08) [_][_][_][8] [6, 2, 4, 9]
(08) (08) [_][_][8][_] [6, 2, 4, 9]
(09) (08) [_][8][_][_] [6, 2, 4, 9]
(10) (08) [8][_][_][_] [6, 2, 4, 9]
(11) (06) [_][_][_][6] [2, 4, 9]
(12) (08) [_][_][6][2] [4, 9]
(13) (12) [_][6][2][4] [9]
(14) (12) [6][2][4][_] [9]
(15) (06) [2][4][_][_] [9]
(16) (04) [4][_][_][_] [9]
(17) (09) [_][_][_][9] []
(18) (09) [_][_][9][_] []
(19) (09) [_][9][_][_] []
(20) (09) [9][_][_][_] []
(21) (00) [_][_][_][_] []

21
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

Java

  • 트럭 클래스를 정의하고 다리 최초 진입 시의 진행 단계(stage)와 다리를 다 건넜을 때의 단계를 기록한다.
  • 트럭은 한 번 다리에 올라가면 다리 길이 만큼 진행 후에 다리를 건넌 상태가 된다.
  • 제일 마지막으로 지나간 트럭의 종료 단계를 출력한다.
import java.util.Scanner;

public class TruckTimer {
    public static int process(String input1, String input2) {
        String[] inputList1 = input1.split(" ");
        String[] inputList2 = input2.split(" ");
        int w = Integer.parseInt(inputList1[1]);
        int l = Integer.parseInt(inputList1[2]);
        Truck[] trucks = new Truck[inputList2.length];
        for (int i = 0; i < trucks.length; i++) {
            int weight = Integer.parseInt(inputList2[i]);
            trucks[i] = new Truck(weight);
        }
        return checkTime(w, l, trucks);
    }

    private static int checkTime(int w, int l, Truck[] trucks) {
        int stage = 1;
        int currentWeight = 0;
        for (int i = 0; i < trucks.length; i++) {
            for (int j = 0; j <= i; j++) {
                if (trucks[j].endStage == stage) {
                    currentWeight -= trucks[j].weight;
                }
            }
            if (currentWeight + trucks[i].weight <= l) {
                currentWeight += trucks[i].weight;
                trucks[i].startStage = stage;
                trucks[i].endStage = stage + w;
                stage++;
            } else {
                stage += w;
                trucks[i].startStage = stage;
                trucks[i].endStage = stage + w;
            }
        }
        return trucks[trucks.length-1].endStage;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String input1 = sc.nextLine();
        String input2 = sc.nextLine();
        System.out.println(TruckTimer.process(input1, input2));
    }
}

class Truck {
    public final int weight;
    public int startStage;
    public int endStage;
    public Truck(int weight) {
        super();
        this.weight = weight;
    }
}
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

Ruby

def min_times
  (_,w,l), trucks = (1..2).map {gets.split.map &:to_i}
  add = ->b,c,t { b.shift; b.sum <= l-t ? [b<<t, c+1] : add[b<<0, c+1, t] }
  puts trucks.reduce([[0]*w,0]) {|a,truck| add[*a,truck] }[1] + w
end

Test

# stdin datas
case1 = "4 2 10\n7 4 5 6\n" 
case2 = "1 100 100\n10\n"   
case3 = "10 100 100\n10 10 10 10 10 10 10 10 10 10\n"
$stdin = StringIO.new(case1 + case2 + case3)

expect{ min_times }.to output("8\n").to_stdout   # case 1
expect{ min_times }.to output("101\n").to_stdout # case 2
expect{ min_times }.to output("110\n").to_stdout # case 3

Output

min_times
11 2 10
7 4 5 6 1 4 2 3 5 7 4
17
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.
#include <cstdlib>
#include <iostream>

using namespace std;

int count_zero(int *a,int m){
     int i;
     for(i=0;i<m;i++){
                      if(a[i]!=0)return 1;
                      }
      return 0;               
}

int count_sum(int *b,int m){
      int i;
      int sum=0;
      for(i=0;i<m;i++){
                       sum=sum+b[i];
                       }
      return sum;                      
}


int  clean1(int *a,int m,int n){

     int i;

     for(i=0;i<m;i++){
                      if(a[i]==n){
                                  a[i]=0;
                                  return 0;
                                  }
                      }
     return 1;
     }


int main(int argc, char *argv[])
{
    FILE* stream1;

    int m,w,n;//m 차량수 ,w 다리길이, n 하중한계 

    int i,j;

    //int a[100]={0,};
    int *a;
    int *b;
    int z=0;
    //int b[100]={0,};
    int sum=0;

    stream1=fopen("1.txt","r");

    fscanf(stream1,"%d %d %d",&m,&w,&n);

    a=new int[m];
    b=new int[w];
    memset(a, 0, m * sizeof(int));
    memset(b, 0, w * sizeof(int));  

    for(i=0;i<m;i++){
                     fscanf(stream1,"%d",&a[i]);
                     } 

    //memset(a, 0, m * sizeof(int));
    //memset(b, 0, w * sizeof(int));          
    while(count_zero(a,m)){


                           for(i=w-1;i>=0;i--){
                                             if(b[i]!=0&&i==w-1){

                                                               // b[i+1]=b[i];
                                                                clean1(a,m,b[i]);
                                                                b[i]=0;

                                                                }



                                             if(b[i]==0&&i!=0){
                                                                  b[i]=b[i-1];
                                                                  b[i-1]=0;  
                                                                  }
                                            /*
                                            if(b[i]!=0&&i!=w-1){                                                               
                                                                //clean1(a,m,b[i]);
                                                                b[i+1]=b[i];
                                                                b[i]=0;
                                                                i--;
                                                                }
                                            */
                                            }



                           if(b[0]==0&&count_sum(b,w)+a[z]<=n){

                                                             b[0]=a[z];
                                                             //printf("%d\n",b[0]);
                                                             z++;
                                                             }                
                          /* 
                          for(i=0;i<w;i++){
                                           printf("%d ",b[i]);
                                           }
                          printf("\n");
                          /*
                          for(i=0;i<m;i++){
                                           printf("%d ",a[i]);
                                           }
                          printf("\n");                          
                           */ 
                           sum++;
                           }

    delete []a;
    delete []b;
    printf("%d\n",sum);
    system("PAUSE");
    return EXIT_SUCCESS;
}
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

JAVA

Truck, Bridge 클래스를 만들었습니다. Truck 자신의 위치를 알고 있습니다. Bridge 클래스는 현재 건너고 있는 트럭들을 리스트로 갖습니다. 리스트에 있는 트럭을 한 번에 시행에서 모두 왼쪽으로 이동합니다. 저는 W값에서 0으로 이동하면 다 이동했다고 판단하여 그 트럭을 리스트에서 제거 시킵니다. 트럭을 추가할 때는 현재 새로 들어올 트럭이 totalWeight에 포함이 되어도 최대 하중을 버틸 수 있는지 체크를 합니다. 버틸 수 있다면 리스트에 추가를 합니다. main 함수에는 모든 트럭이 추가됐는지 또는 모든 트럭이 다리를 지나갔는지 두 가지를 판단하여 while 문을 돌립니다.

Truck 트럭 클래스

public static class Truck {
        private int weight;
        private int position;

        public Truck(int position, int weight) {
            this.position = position;
            this.weight = weight;
        }

        public void decraese() {
            this.position--;
        }

        public int getPosition() {
            return this.position;
        }
        public int getWeight() {
            return weight;
        }
    }

Bridge 클래스

public static class Bridge {
        private int W;
        private int L;
        private ArrayList<Truck> trucks;
        int totalWeight = 0;
        public Bridge(int w, int l) {
            W = w;
            L = l;
            trucks = new ArrayList<>();
        }

        public void moveLeft() {
            Truck removed = null;
            if (trucks == null) {
                return;
            }
            if (trucks.size() < 1) {
                return;
            }
            for (Truck truck : trucks) {
                truck.decraese();
                if(truck.getPosition() < 1) {
                    totalWeight -= truck.getWeight();
                    removed = truck;
                }
            }
            if (removed != null) {
                trucks.remove(removed); 
            }
        }
        public int trucksSize() {
            return trucks.size();
        }
        public void enterTruck(Truck truck) {
            totalWeight += truck.getWeight();
            trucks.add(truck);
        }
        public boolean ableEnterTruck(int weight) {
            if (totalWeight + weight <= L && trucks.size() < W) {
                return true;
            } else {
                return false;
            }
        }
    }

Main 클래스


public class TruckACM2016 {

    static final int SIZE = 1000;
    static int n, w, l;


    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] A = getInput(args);

        int i=0;
        int count =0;
        Bridge bridge = new Bridge(w, l);
        Truck truck;
        while(i<n || bridge.trucksSize() > 0) {
            bridge.moveLeft();
            if (i<n && bridge.ableEnterTruck(A[i])) {
                truck = new Truck(w, A[i]);
                bridge.enterTruck(truck);
                i++;
            }
            count++;
        }
        System.out.println("count : "+count);

    }

    public static int[] getInput(String[] args) {
        int i = 0;
        int[] input = new int[SIZE];
        n = Integer.valueOf(args[i++]);
        w = Integer.valueOf(args[i++]);
        l = Integer.valueOf(args[i++]);
        for (; i<n+3; i++) {
            input[i-3] = Integer.valueOf(args[i]);
        }
        return input;
    }

※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

루비와 대조되는 하드코딩 버젼

JavaScript

class Truck {
    constructor(weight, location) {
        this.weight = (weight || 1);
        this.location = (location || 0);
    }
    Move(dist) {
        this.location += dist;
    }
}
class myArray extends Array {
    constructor() {
        super();
    }
    RemoveByIndex(index) {
        if (index >= 0 && index < this.length)
            return this.splice(index, 1);
    }
}
class Bridge {
    constructor(length, maxWeight) {
        this.length = length;
        this.maxWeight = maxWeight;
        this.arr = new myArray();
    }
    CalcAllWeight() {
        var sum = 0;
        for (var obj of this.arr)
            sum += obj.weight;
        return sum;
    }
    CheckEntry(nextObj) {
        if (nextObj.weight > this.maxWeight)
            return "overweight";
        if (this.CalcAllWeight() + nextObj.weight > this.maxWeight)
            return false;
        return true;
    }
    In(obj) {
        this.arr.push(obj);
    }
    Out() {
        return this.arr.RemoveByIndex(0);
    }
}
class EntrySimulator {
    constructor() {
        this.bridge = new Bridge();
        this.trucks = new myArray();
    }
    SetOptions(w, L) { //w는 길이, L은 최대하중
        this.bridge = new Bridge(w, L);
    }
    SetTrucks(arr) {
        for (var i = 0; i < arr.length; i++) {
            this.trucks.push(new Truck(parseInt(arr[i]), i));
        }
    }
    Calculate() {
        var timediff = 0,
            passed = 0,
            entered = 0,
            error = undefined;
        while(!error && passed < this.trucks.length) { //이 while문을 한번 돌 때마다 한 턴(unit time)이 지나감.
            timediff++;
            for (var i = passed; i < entered; i++) { //다리 위에 올라와있는 트럭들이 먼저 이동함.
                this.trucks[i].Move(-1);
            }
            if (this.trucks[passed].location < -this.bridge.length) {
                this.bridge.Out(); //다리 위의 제일 앞 트럭이 통과했다면 관련 처리를 함.
                passed++;
            }
            if (entered >= this.trucks.length) //다리에 진입하지 못한 트럭이 더 없다면 뒷부분은 거칠 필요 없음.
                continue;
            switch (this.bridge.CheckEntry(this.trucks[entered])) { //다리 앞에 있는 트럭이 다리로 올라올 수 있는지 검사.
                case true :
                    this.bridge.In(this.trucks[entered]);
                    for (var i = entered; i < this.trucks.length; i++) { //다리 앞의 트럭이 올라왔으므로 그 트럭과 뒤의 모든 트럭들이 한칸씩 이동함.
                        this.trucks[i].Move(-1);
                    }
                    entered++;
                    break;
                case "overweight" : //입력 단계에서 걸러지지만 언젠가 있을 오류를 대비하여 작성.
                    error = true;
                    alert("초과중량 차량이 있습니다. 현재 초과중량 차량에 대한 대응 메뉴얼이 없습니다.");
                    break;
            }
        }
        return timediff;
    }
}
function FilteringResult(plain, num) { //num을 입력하지 않으면 갯수제한 없이 전부 반환함.
    var arr = plain.split(' ', num); //띄워쓰기를 기준으로 문자열을 나눔. num보다 갯수가 많으면 그 뒤는 버려짐.
    if (arr.length == 1)
        arr = arr.split(',', num); //띄워쓰기가 아니라면 쉼표를 기준으로 나눔.
    console.log(arr);
    for (var i = 0; i < arr.length; i++) {
        arr[i] = arr[i].replace(/[^0-9]/g,''); //각 문자열에서 숫자를 제외하고 모두 제거.
    }
    console.log(arr);
    return arr;
}
function Simulate() {
    var simulator = new EntrySimulator();
    var truck_num = 1, bridge_length, bridge_limit;
    const MIN_NUM = 1, MAX_NUM = 1000,
          MIN_LEN = 1, MAX_LEN = 100,
          MIN_WTL = 10, MAX_WTL = 1000;
    while (true) {
        var result = FilteringResult(prompt("Set number of trucks(1 ~ 1000), bridge length(1 ~ 100), bridge max weight(10 ~ 1000). use space or comma as separator.", "4 2 10"), 3);
        truck_num = result[0];
        bridge_length = result[1];
        bridge_limit = result[2];
        if (truck_num < MIN_NUM) {
            alert("트럭이 최소 한 대는 있어야 합니다"); //제한에 걸리지 않을 때까지 계속 입력을 반복함.
            continue;
        }
        if (truck_num > MAX_NUM) {
            alert("트럭의 갯수가 너무 많습니다");
            continue;
        }
        if (bridge_length < MIN_LEN) {
            alert("다리의 길이가 너무 짧습니다.");
            continue;
        }
        if (bridge_length > MAX_LEN) {
            alert("다리의 길이가 너무 깁니다.");
            continue;
        }
        if (bridge_limit < MIN_WTL) {
            alert("최대 하중이 너무 작습니다.");
            continue;
        }
        if (bridge_limit > MAX_WTL) {
            alert("최대 하중이 너무 큽니다.");
            continue;
        }
        break; //어떤 제한에도 걸리지 않으면 통과.
    }
    simulator.SetOptions(bridge_length, bridge_limit);
    var trucks;
    const MIN_TW = 1, MAX_TW = 10;
    while(true) {
        var result = FilteringResult(prompt("Input weight of each trucks(1 ~ 10)", "7 4 5 6"), truck_num);
        var error = false;
        for (var i = 0; i < result.length; i++) {
            result[i] = parseInt(result[i]);
            if (result[i] < MIN_TW) {
                alert("트럭의 무게가 너무 작습니다.");
                error = true;
                break;
            }
            if (result[i] > MAX_TW) {
                alert("트럭의 무게가 너무 큽니다.");
                error = true;
                break;
            }
        }
        if (!error)
            break;
    }
    simulator.SetTrucks(result);
    alert("Result : " + simulator.Calculate() + " unit time");
}
window.addEventListener('load', Simulate);

※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.
while __name__ == '__main__':
    #입력
    for s in ['n, w, L', 't']:
        exec(s + ''' = [*map(int, input('>>>').split())]''')
    #다리를 w개의 칸을 가진 리스트로 만듦.
    bridge = [0] * w; end = bridge[:]
    #i를 1부터 세기 시작
    for i in __import__('itertools').count(1):
        #남은 트럭이 있고 다리가 곧 나가는 트럭을 제외한 트럭을 버틸 수 있으면
        if t != [] and sum(bridge[1:]) + t[0] <= L:
            #남은 트럭을 빼서 다리에 트럭 추가
            bridge += [t.pop(0)]
        else:
            #아니면 빈칸 추가
            bridge += [0]
        #한칸 전진
        bridge = bridge[1:]
        #다리가 비어있고 남은 트럭이 없으면
        if bridge == end and t == []:
            #시간을 출력하고 종료
            print(i)
            break

짧은 버전

while __name__ == '__main__':
    for s in ['n, w, L', 't']:
        exec(s + ''' = [*map(int, input('>>>').split())]''')
    bridge = [0] * w; end = bridge[:]
    i = 1
    while True:
        bridge = bridge[1:] + ([t.pop(0)] if t != [] and sum(bridge[1:]) + t[0] <= L else [0])
        if bridge == end and t == []:
            print(i)
            break
        i += 1

파이썬 3.5.2 64

※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

#n number of truck
#w bridge length
#l weight
def Cross_the_bridge(n,w,l):
    count,t=0,0
    d_list=[0 for i in range(0,w)]
    c=raw_input().split()
    c_list=[int(i) for i in c] 
    while(len(c_list)!=0):
        count=0
        if(sum(d_list)==0):
            for j in range(0,n+1):
                if(j<=w):
                    if(sum(c_list[0:j])>l):
                        break
            for k in range(0,w):
                if(len(c_list)==0):
                    break
                c_n=c_list.pop(0)
                d_list[count]=c_n
                count+=1
                t+=1

        for i in range(0,w):
            d_list[i]=0
            t+=1
        ##print d_list
        ##print len(c_list)
    print t

Cross_the_bridge(4,2,10)
Cross_the_bridge(1,100,100)               
Cross_the_bridge(10,100,100)   

for문을 이용해서 다리위에 있는 트럭의 무게합이 0일 경우 다리 길이 만큼 무게합이 다리 무게보다 작거나 같을때까지 다리위에 올려 이동시키고 이동할때 마다 시간을 1씩 증가 시키면서 풀었습니다.

  • 입력:4 2 10 결과:8
  • 입력:1 100 100 결과:101
  • 입력:10 100 100 답"110
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.
def solution(n,w,L,a):
    count = 0
    b = a + [0]
    for i, weight in enumerate(b):
        if b[i] < L and b[i] != 0:
            count += 1
            if b[i+1] < L - b[i]:
                pass
            else:
                count += w-1
        else:
            break
    count = count + w
    return count

Python 3.5.2

입력을 두줄로 하라는 부분은 생략했습니다. 일단 주어진 샘플 입력값들을 넣어보면 다 맞게 나옵니다. 잘못된 부분이 있으면 지적 부탁드립니다.

※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

CPP code queue를 이용한 구현문제

#include <iostream> 
#include <cstdlib> 
#include <queue> 
using namespace std;  

int main(){
    ios_base::sync_with_stdio(false); 
    cin.tie(NULL); 
    int N,W,L; 
    cin >> N >> W >> L;  
    int sum = 0,cnt = 0,ret = 0,truck;  
    queue<int> que; 
    for (int i = 0; i < N; i++){
        cin >> truck; 
        while (true){
            ++ret; 
            if (cnt == W){
                --cnt;  
                sum -= que.front(); 
                que.pop();  
            }
            if (sum+truck > L){
                ++cnt; 
                que.push(0);  
            }else{
                ++cnt; 
                sum += truck;  
                que.push(truck);  
                break; 
            }
        }
    }
    cout << ret+W << endl; 
    return 0; 
}
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

풀이 작성

※ 풀이작성 안내
  • 본문에 코드를 삽입할 경우 에디터 우측 상단의 "코드삽입" 버튼을 이용 해 주세요.
  • 마크다운 문법으로 본문을 작성 해 주세요.
  • 풀이를 읽는 사람들을 위하여 풀이에 대한 설명도 부탁드려요. (아이디어나 사용한 알고리즘 또는 참고한 자료등)
  • 작성한 풀이는 다른 사람(빨간띠 이상)에 의해서 내용이 개선될 수 있습니다.
목록으로
코딩도장

코딩도장은 프로그래밍 문제풀이를 통해서 코딩 실력을 수련(Practice)하는 곳입니다.


언어별 풀이 현황
전 체 x 20
기 타 x 2
java x 4
ruby x 1
cpp x 3
javascript x 1
python x 9