코딩도장

변경이력

12 134개 문자 추가 191개 문자 삭제

2017年04月02日 15:39

**Ruby** 빠른 둘로 가장 느린 둘을 이동시키는 시간을 한 사이클로 두면 수식으로 일반화 가능. 최초 입력값 정렬한 뒤 수식에 대입. a,b를 가장 빠른 둘, rest를 나머지라 할 때, 전체이동시간 = (a x a단독이동횟수) + (b x b의 이동횟수) + (느린 멤버 둘씩 이동하는 시간의 총합) ```{.ruby} sum = ->def safe_time(students, times=students.split.map(&:to_i)) size,(a,b,*rest,size {) = times.shift, times.sort rest[0] ? a*(size+-1)/2 + b*(size+-1 - size%2) + rest.reverse.each_slice(2).map(&:first).sum } safe_time = ->times { a,b,*rest = times.split.map(&:to_i).drop(1).sort rest[0] ? sum[a,b,rest,rest.size] : b || a } : b||a end ``` **Test** ```{.ruby} expect( safe_time[("2 15 5"]) ).to eq 15 expect( safe_time[("4 1 2 7 10"]) ).to eq 17 expect( safe_time[("5 12 1 3 8 6"]) ).to eq 29 ``` **Output** ```{.ruby} #=> puts safe_time[("4 1 2 7 10"] ) #=> 17 ```

11 12개 문자 추가 2개 문자 삭제

2016年08月30日 12:01

**Ruby** 빠른 둘로 가장 느린 둘을 이동시키는 시간을 한 사이클로 두면 수식으로 일반화 가능. 최초 입력값 정렬한 뒤 수식에 대입. a,b를 가장 빠른 둘, rest를 나머지라 할 때, 전체이동시간 = (a* x a단독이동횟수) + (b* x b의 이동횟수) + (느린 멤버 둘씩 이동하는 시간의 총합) ```{.ruby} sum = ->a,b,rest,size { a*(size+1)/2 + b*(size+1 - size%2) + rest.reverse.each_slice(2).map(&:first).sum } safe_time = ->times { a,b,*rest = times.split.map(&:to_i).drop(1).sort rest[0] ? sum[a,b,rest,rest.size] : b || a } ``` **Test** ```{.ruby} expect( safe_time["2 15 5"] ).to eq 15 expect( safe_time["4 1 2 7 10"] ).to eq 17 expect( safe_time["5 12 1 3 8 6"] ).to eq 29 ``` **Output** ```{.ruby} #=> puts safe_time["4 1 2 7 10"] 17 ```

10 207개 문자 추가 222개 문자 삭제

2016年08月30日 11:53

**Ruby** 빠른 둘로 가장 느린 둘을 이동시키는 시간을 한 사이클로 두면 수식으로 일반화 가능(홀/짝 두가지). f1,f2. 최초 입력값 정렬한 뒤 수식에 대입. a,b를 가장 빠른 둘, rest를 나머지라 할 때, 전체이동시간 = (f1 x 단독a*이동횟수) + (f2 x 단독b*이동횟수) + (느린 2명이멤버 둘씩 이동하는 시간의 총합) ```{.ruby} sum = ->f1,f2,rest { f1*(rest.a,b,rest,size { a*(size+1)/2 + f2*(rest.b*(size+1 - rest.size%2) + rest.reverse.each_slice(2).map(&:first).reduce(:+) } time = ->stdt { stdt.size > 2 ? sum[*stdt.shift(2), stdt] : stdt[-1] } safe_time = ->input { time[input.split.map(&:to_i).drop(1).sort] }sum } safe_time = ->times { a,b,*rest = times.split.map(&:to_i).drop(1).sort rest[0] ? sum[a,b,rest,rest.size] : b || a } ``` **Test** ```{.ruby} expect( safe_time["2 15 5"] ).to eq 15 expect( safe_time["4 1 2 7 10"] ).to eq 17 expect( safe_time["5 12 1 3 8 6"] ).to eq 29 ``` **Output** ```{.ruby} #=> puts safe_time["4 1 2 7 10"] 17 ```

9 4개 문자 추가 4개 문자 삭제

2016年06月26日 02:31

**Ruby** 빠른 둘로 가장 느린 둘을 이동시키는 시간을 한 사이클로 두면 수식으로 일반화 가능(홀/짝 두가지). f1,f2를 가장 빠른 둘, rest를 나머지라 할 때, 전체이동시간 = (f1 x 단독이동횟수) + (f2 x 단독이동횟수) + (느린 2명이 이동하는 시간의 총합) ```{.ruby} sum = ->f1,f2,rest { f1*(rest.size+1)/2 + f2*(rest.size+1 - rest.size%2) + rest.reverse.each_slice(2).map(&:first).reduce(:+) } time = ->stdt { stdt.size > 2 ? sum[*stdt.shift(2), stdt] : stdt.max[-1] } safe_time = ->input { time[input.split.map(&:to_i).drop(1).sort] } ``` **Test** ```{.ruby} expect( safe_time["2 15 5"] ).to eq 15 expect( safe_time["4 1 2 7 10"] ).to eq 17 expect( safe_time["5 12 1 3 8 6"] ).to eq 29 ``` **Output** ```{.ruby} #=> puts safe_time["4 1 2 7 10"] 17 ```

8 11개 문자 추가 3개 문자 삭제

2016年06月26日 02:30

**Ruby** 빠른 둘로 가장 느린 둘을 이동시키는 시간을 한 사이클로 두면 수식으로 일반화 가능(홀/짝 두가지). f1,f2를 가장 빠른 둘, rest를 나머지라 할 때, 전체이동시간 = (f1 x 단독이동횟수) + (f2 x 단독이동횟수) + (느린2명의이 이동시간하는 시간의 총합) ```{.ruby} sum = ->f1,f2,rest { f1*(rest.size+1)/2 + f2*(rest.size+1 - rest.size%2) + rest.reverse.each_slice(2).map(&:first).reduce(:+) } time = ->stdt { stdt.size > 2 ? sum[*stdt.shift(2), stdt] : stdt.max } safe_time = ->input { time[input.split.map(&:to_i).drop(1).sort] } ``` **Test** ```{.ruby} expect( safe_time["2 15 5"] ).to eq 15 expect( safe_time["4 1 2 7 10"] ).to eq 17 expect( safe_time["5 12 1 3 8 6"] ).to eq 29 ``` **Output** ```{.ruby} #=> puts safe_time["4 1 2 7 10"] 17 ```

7 1개 문자 삭제

2016年06月26日 02:28

**Ruby** 빠른 둘로 가장 느린 둘을 이동시키는 시간을 한 사이클로 두면 수식으로 일반화 가능(홀/짝 두가지). f1,f2를 가장 빠른 둘, rest를 나머지라 할 때, 전체이동시간 = (f1 x 단독이동횟수) + (f2 x 단독이동횟수) + (느린2명의 이동시간) ```{.ruby} sum = ->f1,f2,rest { f1*(rest.size+1)/2 + f2*(rest.size+1 - rest.size%2) + rest.reverse.each_slice(2).map(&:first).reduce(:+) } time = ->stdt { stdt.size > 2 ? sum[*stdt.shift(2), stdt] : stdt.max } safe_time = ->input { time[input.split.map(&:to_i).drop(1).sort] } ``` **Test** ```{.ruby} expect( safe_time["2 15 5"] ).to eq 15 expect( safe_time["4 1 2 7 10"] ).to eq 17 expect( safe_time["5 12 1 3 8 6"] ).to eq 29 ``` **Output** ```{.ruby} #=> puts safe_time["4 1 2 7 10"] 17 ```

6 3개 문자 추가 2개 문자 삭제

2016年06月26日 02:27

**Ruby** 빠른 둘로 가장 느린 둘을 이동시키는 것이시간을 한 사이클로 두면 수식으로 일반화 가능(홀/짝 두가지). f1,f2를 가장 빠른 둘, rest를 나머지라 할 때, 전체이동시간 = (f1 x 단독이동횟수) + (f2 x 단독이동횟수) + (느린2명의 이동시간) ```{.ruby} sum = ->f1,f2,rest { f1*(rest.size+1)/2 + f2*(rest.size+1 - rest.size%2) + rest.reverse.each_slice(2).map(&:first).reduce(:+) } time = ->stdt { stdt.size > 2 ? sum[*stdt.shift(2), stdt] : stdt.max } safe_time = ->input { time[input.split.map(&:to_i).drop(1).sort] } ``` **Test** ```{.ruby} expect( safe_time["2 15 5"] ).to eq 15 expect( safe_time["4 1 2 7 10"] ).to eq 17 expect( safe_time["5 12 1 3 8 6"] ).to eq 29 ``` **Output** ```{.ruby} #=> puts safe_time["4 1 2 7 10"] 17 ```

5 1개 문자 추가 4개 문자 삭제

2016年06月26日 02:26

**Ruby** 빠른 둘로 가장 느린 둘을 이동시키는 것이 한 사이클로 두면 수식으로 일반화 가능.(홀/짝 두가지).f1,f2를 가장 빠른 둘, rest를 나머지라 할 때, 전체이동시간 = (f1 x 단독이동횟수) + (f2 x 단독이동횟수) + (느린2명의 이동시간) ```{.ruby} sum = ->f1,f2,rest { f1*(rest.size+1)/2 + f2*(rest.size+1 - rest.size%2) + rest.reverse.each_slice(2).map(&:first).reduce(:+) } time = ->stdt { stdt.size > 2 ? sum[*stdt.shift(2), stdt] : stdt.max } safe_time = ->input { time[input.split.map(&:to_i).drop(1).sort] } ``` **Test** ```{.ruby} expect( safe_time["2 15 5"] ).to eq 15 expect( safe_time["4 1 2 7 10"] ).to eq 17 expect( safe_time["5 12 1 3 8 6"] ).to eq 29 ``` **Output** ```{.ruby} #=> puts safe_time["4 1 2 7 10"] 17 ```

4 5개 문자 추가 3개 문자 삭제

2016年06月26日 02:25

**Ruby** 빠른 둘로 가장 느린 둘을 이동시키는 것이 한사이클일 때로 두면 수식으로 일반화 가능.(홀/짝 두가지) f1,f2를 가장 빠른 둘, rest를 나머지라 할 때, 전체이동시간 = (f1 x 단독이동횟수) + (f2 x 단독이동횟수) + (느린2명의 이동시간) ```{.ruby} sum = ->f1,f2,rest { f1*(rest.size+1)/2 + f2*(rest.size+1 - rest.size%2) + rest.reverse.each_slice(2).map(&:first).reduce(:+) } time = ->stdt { stdt.size > 2 ? sum[*stdt.shift(2), stdt] : stdt.max } safe_time = ->input { time[input.split.map(&:to_i).drop(1).sort] } ``` **Test** ```{.ruby} expect( safe_time["2 15 5"] ).to eq 15 expect( safe_time["4 1 2 7 10"] ).to eq 17 expect( safe_time["5 12 1 3 8 6"] ).to eq 29 ``` **Output** ```{.ruby} #=> puts safe_time["4 1 2 7 10"] 17 ```

3 275개 문자 추가 177개 문자 삭제

2016年06月26日 02:25

**Ruby** 가장 작은 수 두개로 가장 큰 두개의 수를 기숙사로빠른 둘로 가장 느린 둘을 이동시키는 것을이 한사이클일 때 수식으로 일반화 시킵니다가능.(홀수/짝수 두가지 케이스가 발견됩니다.)) f1,f2를 가장 빠른 둘, rest를 나머지라 할 때, 전체이동시간 = (f1 x 단독이동횟수) + (f2 x 단독이동횟수) + (느린2명의 이동시간) ```{.ruby} calcsum = ->mf1,mf2,p { m1 * (prest { f1*(rest.size+1)/2 + m2 * (pf2*(rest.size+1 - prest.size%2) +p rest.reverse.each_slice(2).map(&:first).reduce(:+) } time = ->p { pstdt { stdt.size > 2 ? calc[*p.sort!.shift(2), p] : p.max } min_tsum = ->strsum[*stdt.shift(2), stdt] : stdt.max } safe_time = ->input { time[strinput.split.map(&:to_i).drop(1)] } .sort] } ``` **Test** ```{.ruby} expect( min_tsumsafe_time["2 15 5"] ).to eq 15 expect( min_tsumsafe_time["4 1 2 7 10"] ).to eq 17 expect( min_tsumsafe_time["5 12 1 3 8 6"] ).to eq 29 ``` **Output** ```{.ruby} #=> puts min_tsumsafe_time["4 1 2 7 10"] 17 ```

2 15개 문자 추가 60개 문자 삭제

2016年06月09日 04:17

**Ruby** 가장 작은 수 두개로 가장 큰 두개의 수를 기숙사로 이동시키는 것을 한 사이클로 일반화 시킵니다.(홀수/짝수 두가지 케이스가 발견되는데 별도기법이나 알고리즘 필요없이 그대로 구현하면 됩니다..) ```{.ruby} processcalc = ->m1,m2,p { m1 * (p.size+1)/2 + m2 * (p.size+1 - p.size%2) * m2 + p.reverse.each_slice(2).map(&:first).reduce(:+) } m_times = ->p { p.size > 2 ? processcalc[*p.sort!.shift(2), p] : p.max } min_tsum = ->str { m_times[str.split.map(&:to_i).drop(1)] } ``` **Test** ```{.ruby} expect( min_tsum["2 15 5"] ).to eq 15 expect( min_tsum["4 1 2 7 10"] ).to eq 17 expect( min_tsum["5 12 1 3 8 6"] ).to eq 29 ``` **Output** ```{.ruby} #=> puts min_tsum["4 1 2 7 10"] 17 ```

1 Original

2016年06月08日 19:56

**Ruby** 가장 작은 수 두개로 가장 큰 두개의 수를 기숙사로 이동시키는 것을 한 사이클로 일반화 시킵니다. 홀수/짝수 두가지 케이스가 발견되는데 별도기법이나 알고리즘 필요없이 그대로 구현하면 됩니다.. ```{.ruby} process = ->m1,m2,p { m1 * (p.size+1)/2 + (p.size+1 - p.size%2) * m2 + p.reverse.each_slice(2).map(&:first).reduce(:+) } m_times = ->p { p.size > 2 ? process[*p.sort!.shift(2), p] : p.max } min_tsum = ->str { m_times[str.split.map(&:to_i).drop(1)] } ``` **Test** ```{.ruby} expect( min_tsum["2 15 5"] ).to eq 15 expect( min_tsum["4 1 2 7 10"] ).to eq 17 expect( min_tsum["5 12 1 3 8 6"] ).to eq 29 ``` **Output** ```{.ruby} #=> puts min_tsum["4 1 2 7 10"] 17 ```

코딩도장

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

피드백 · 개인정보취급방침 · RSS