가장 효율적으로 출력하는 경우는

한 장에 X시간 걸리는 프린터는 전체의 출력 양 중 Y/(X+Y) * 100 %를, 한 장에 Y시간 걸리는 프린터는 전체의 출력 양 중 X/(X+Y) * 100 %를 출력하는 경우입니다.

그런데 마지막 장은 두 프린터가 동시에 출력할 수 없으니 양쪽 프린터 중 어떤 프린터가 마지막 장을 출력할 시 더 빠른지 두 가지 경우를 모두 계산합니다.

그리고 빠른 프린터가 마지막 장을 출력한 경우, 느린 프린터가 마지막 장을 출력한 경우 중 더 빨랐던 값을 반환합니다. 마지막 장을 출력하지 않은 프린터의 소요시간은 마지막 장을 출력한 프린터의 소요시간보다 적기 때문에 계산에 고려하지 않습니다.

codingdojo449=function(n1, n2, n3){
  s=n1+n2
  d1=n2/s
  d2=n1/s
  w1=ceiling(n3*d1)
  w2=ceiling(n3*d2)

  min(w1*n1,w2*n2)
}

결과입니다

> codingdojo449(1,1,5)
[1] 3
> codingdojo449(3,5,4)
[1] 9
> codingdojo449(3,5,5)
[1] 10
> codingdojo449(2,3,2)
[1] 3

[Python] 수학문제네요~

def TwoPrint(x,y,n):
    return round( (n-1) / (1/(x*1.0) + 1/(y*1.0)) + min(x,y)) 


print TwoPrint(1,1,5)
print TwoPrint(3,5,4)

3.0
9.0

import math
def printers(x,y,n):
    t=1
    while True:
        if math.floor(t/x)+math.floor(t/y)>=n:
            return t
        t+=1

printers(1,1,5)
printers(3,5,4)

좋은 알고리즘이 있을것 같지만 일단 무식하게 풀어보았습니다.

python.

#
# two printers
#

def two_printers(x, y, n):
    m = None
    i = 0
    while i<=n:
        elapsed = max(x*i, y*(n-i))
        if not m or elapsed < m:
            m = elapsed
        i += 1
    return m


print two_printers(1,1,5)
print two_printers(3,5,10)

def optprint():
        print ("input data:")
        notc = input()
        tc = []
        i = 0
        while i < notc:
                a = raw_input()
                tc.append(a)
                i += 1

        print ("")
        print ("answer:")

        j = 0
        while j < notc:
                tcx = tc[j].split(' ')
                k = 1
                elapse = []
                x = int(tcx[0])
                y = int(tcx[1])
                n = int(tcx[2])
                while k < n:
                        elapse.append( max(x*k, y*(n-k)) )
                        k += 1
                print min(elapse),
                j += 1
        return

optprint()

#python 3.2.5

def calc(X,Y,N):
    '''
    a + b = N
    T = a*X or b*Y
    a*X - b*Y == 0 일 때 가장 짧은 시간
    b = (N*X) / (X+Y)

    종이는 장 단위로 자연수만 가능하므로 b 근처[int(b) ~ int(b)+1]
    '''
    b1 = int((N*X) / (X+Y))
    a1 = N-b1
    T1 = max((a1*X, b1*Y))

    b2 = b1+1
    a2 = N-b2 #(a1-1)
    T2 = max((a2*X, b2*Y))

    if T1 < T2:
        return T1
    return T2

def lines(string):
    b,e = 0,string.find('\n')
    while e != -1:
        s = string[b:e].strip()
        b,e = e,string.find('\n', e+1)
        if not(s): continue
        yield s

    raise StopIteration

def solve(input_string):
    rt = []
    for l in lines(input_string):
        numbers = l.split(' ')
        if len(numbers) == 3:
            rt.append( str(calc(int(numbers[0]), int(numbers[1]), int(numbers[2]))) )
    return ' '.join(rt)
def main():

    data = '''
    2
    1 1 5
    3 5 4
    '''
    print(solve(data))

파이썬입니다

def printers(a,b,n):
    y=1.0
    ans_list=[]
    while True:
        x = n*min(a,b)-min(a,b)*y/max(a,b)
        if (x%1==0 and y%1==0):
            ans_list.append(max(x,y))
        if (min(x,y)<=0):
            break
        y+=1.0
    return min(ans_list)

print printers(1.0,1.0,5.0)
print printers(3.0,5.0,4.0)

def printer(a,b,n):
    time=[0,0]
    a=int(a)
    b=int(b)
    for i in range(int(n)):
        if time[0]+a<time[1]+b:
            time[0]+=a
        else:
            time[1]+=b
    return max(time[0],time[1])

멍청하게했네요 반성합니다 ㅠㅠ

파이썬 3.4 입니다. 무식하게 풀었습니다.

def cal_time(first, second, page):
    short_time = second * page
    for a in range (1,page):
        first_time = (first * a)
        second_time = (second * page) - (second * a)
        if first_time >= second_time:
            time = first_time
        else:
            time = second_time
        if time < short_time:
            short_time = time
    return short_time

total_test = int(input())
data = []
for x in range (total_test):
    temp = input().split(" ")
    data.append(temp)

result = ''
for x in range (total_test):
    answer = str(cal_time(int(data[x][0]),int(data[x][1]),int(data[x][2])))
    result = result + answer + ' '

print (result)

Perl

sub eta{
    my($x,$y,$n)=@_;
    my $r=sprintf('%.0f',$x*$y*($n-1)/($x+$y));
    $x>$y?$r+=$y:$r+=$x;
    $r;
}
print eta(1,1,5);
print eta(3,5,4);

C#으로 작성했습니다. 한 성탁 님의 로직을 그대로 가져왔네요.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CodingDojang
{

    class CodingDojang
    {
        static void Main(string[] args)
        {
            TwoPrinters.Answer();
        }

    }

    public class TwoPrinters
    {

        public static void Answer()
        {

            var number = int.Parse(Console.ReadLine().ToString());
            var inputLines = new List<string>(number);

            for (int i = 0; i < number; i++)
                inputLines.Add(Console.ReadLine().ToString());

            for(int i = 0; i < number; i++)
            {
                var inputs = inputLines[i].Split(' ').ToList();
                TwoPrinters(int.Parse(inputs.First()), 
                    int.Parse(inputs[1]), int.Parse(inputs.Last()));
            }

        }

        public static void TwoPrinters(int x, int y, int p)
        {

            var sum = x + y;
            var division1 = (decimal) y/sum;
            var division2 = (decimal) x/sum;

            var answer1 = x < y ? Math.Ceiling(division1*p) : Math.Floor(division1*p);
            var answer2 = x < y ? Math.Floor(division2*p) : Math.Ceiling(division2*p);

            Console.WriteLine(Math.Max(answer1*x, answer2*y));

        }

    }

}

    static void exce62()// Two Printers
    {
        Scanner scan = new Scanner(System.in);
        int n = Integer.parseInt(scan.nextLine());
        String[] strArr = new String[n];
        int[] ans = new int[n];

        for (int i = 0; i < n; i++)
        {
            strArr[i] = scan.nextLine();
        }

        for (int i = 0; i < n; i++)
        {
            String[] str = strArr[i].split(" ");

            int X = Integer.parseInt(str[0]);
            int Y = Integer.parseInt(str[1]);
            int N = Integer.parseInt(str[2]);

            int xc = 0, yc = 0;

            while (N > 0)
            {
                if (xc + X < yc + Y)
                    xc++;
                else
                    yc++;

                N--;
            }

            if (xc * X < yc * Y)
                ans[i] = yc * Y;
            else
                ans[i] = xc * X;
        }

        for(int i=0;i<n;i++)
            System.out.printf("%d ",ans[i]);

    }

def printTime(x,y,n):
    a=n*y/(x+y)
    b=n*x/(x+y)
    if a+b == n:
        return max(x*a, y*b)
    else:
        return min(max(x*a+x,y*b),max(x*a,y*b+y))

뭔가 정교하게 짜기가 귀찮아서 근사값을 구한 후에 늘려가면서 최소값을 찾기로 했습니다.

1장에 x초가 걸린다면 1초에는 (1/x)장만큼 뽑아내는 속도를 갖습니다. x, y 초가 걸리는 두 프린터는 k 초 동안 (k/x) + (k/y) 장을 출력할 수 있고 그게 n 이면 되기에 n, x, y 를 알면 k를 구할 수 있습니다. 그런데 k가 x, y 의 배수가 아닌 경우에는 실제 최소 소요시간보다 k가 작게 잡히는 경우가 있어서 그 때부터는 k를 1씩 올려가면서 체크합니다.

def do(x, y, n):
  k = int(n * x * y / (x + y))
  while True:
      if int(k/x) + int(k/y) >= n:
      return k
  k += 1

Ruby

time = ->x,y,n { t=(n*x*y*1.0/(x+y)).ceil;  t%x+t%y > 0? t+1 : t }
rcv = proc { puts "input data:"; (1..gets.to_i).map { gets.split.map &:to_i } }
prt_times = ->input=rcv[] { puts "\nanswer:", input.map(&time)*' ' }

Test

$stdin = StringIO.new("2\n1 1 5\n3 5 4\n")
expected = "input data:\n" +
           "\n" +
           "answer:\n" +
           "3 9\n"
expect { prt_times.call }.to output( expected ).to_stdout

Output

#=> prt_times.call    
input data:
2
1 1 5
3 5 4

answer:
3 9

_list = [list(map(int,input().split(' '))) for x in range(int(input()))]
result = list()
for x in _list:
    X,Y,N = x
    x_count, y_count, s = 0, 0, 0
    while x_count+y_count < N:
        s += 1
        if s % X == 0:
            x_count += 1
        if s % Y == 0:
            y_count += 1
    result.append(s)
print(result)

#### 2017.01.28 D-390 ####

난 수학을 모른다. 고로 노가다한다.

#include <stdio.h>
#include <stdlib.h>

void main() {
    int m =1, n=1;
    int x = 5;
    scanf("%d %d %d", &m, &n, &x);
    int high, low;
    if(m >= n) {
        high = m;
        low = n;
    }
    else {
        low = m;
        high = n;
    }
    int max = high * x;
    int min = high * x;
    for(int i=1;i<x;i++) {
        int j=x-i;
        if(min > (high*i + low*j)) {
            min = high*i + low*j;
            m = high*i;
            n = low*j;
        }
        if(max == high*i + low*j) {
            printf("%d %d", i,j);
            printf("?");
            m=x/2+1;
            n=x/2;
            break;
        }
    }
    if(m >= n)
        printf("%d", m);
    else
        printf("%d", n);
}

이 문제는 이차 방정식으로 풀었습니다. y = bx, y = ax + a*num 이 두 방정식의 교차값이 나올 텐데 소수의 경우가 많을 겁니다. 그러니 그 소숫값의 정수 부분, +1 한 정수 두 경우를 비교해서 작은것을 return 해줍니다. 예시로 input data : 3 5 10인 경우 Y = -3x+30, y=5x 값은 x=15/4가 됩니다. 15/4가 inputdata의 최솟값이 되겠지만 3.75번은 없으니 3, 4 두번의 경우를 돌리고 최솟값을 return 해줍니다. 그러면 값은 20이 나옵니다.(3 : 6번, 5: 4번)

import java.util.Scanner;

public class Two_Printer {
    public void go(){
        Scanner scan = new Scanner(System.in);
        int num = scan.nextInt();
        for(int i = 0; i < num; i++){
            System.out.print(execute(scan.nextInt(), scan.nextInt(), scan.nextInt()) + " ");
        }
    }

    private int execute(int a, int b, int x) {
        int num = 0, a2 = 0, b2 = 0;
        num = (a*x) / (a+b);
        a2 = (a*x) - (a*num);
        b2 = (b * (num+1));
        if(a2 >= b2)
            return b2;
        else
            return a2;
    }
}

import java.util.Scanner;

import static java.lang.System.in;

public class TwoPrinters {
    public static void main(String[] args) {
        Scanner sc = new Scanner(in);
        int t = sc.nextInt();
        int m[][] = new int[t][3];
        for (int i = 0; i < t; i++) {
            m[i][0] = sc.nextInt();
            m[i][1] = sc.nextInt();
            m[i][2] = sc.nextInt();
        }

        for (int i = 0; i < t; i++) {
            int x = m[i][0];
            int y = m[i][1];
            int n = m[i][2];
            int l;
            int k = 1;
            while (true) {
                l = (k / x) + (k / y);
                if (n <= l) {
                    System.out.println(k);
                    break;
                }
                k++;
            }
        }
    }
}

javascript

/*
한 페이지 출력시 각각 x, y초가 걸리는 프린터의 
k초 후 인쇄 장수는 [k/x] + [k/y] 로 계산할 수 있다 
([x] 는 가우스 기호로 x를 넘지 않는 최대 정수)

이 때 다음이 성립한다.
[k/x] + [k/y] <= k/x + k/y 
(등호는 k 가 x, y 의 공배수일 때 성립)

다시 말해 k/x + k/y = n 을 만족시키는 k를 구해도
그 k 값으로는 [k/x] + [k/y] 이 n보다 작거나 같다는 것이다.
즉, 구하고자 하는 값은 k 이상이어야 한다.

그러므로 우선 k/x + k/y = n 을 성립시키는 k를 구한 후에
k 를 1씩 증가시키면서 [k/x] + [k/y] = n 이 되는 k를 구하면 된다.

k/x + k/y = n 식을 변형하면
k = nxy/(x+y) 가 되는데 
이 때 만약 정수가 아니라면 올림을 한다
어차피 1 더해서 검사해봐야 하니까.
*/

var input =
`2
1 1 5
3 5 4`;

var lines = input.split("\n");
var size = parseInt(lines[0].trim());
var data = lines.slice(1).map(v => v.split(" ").map(v => parseInt(v.trim())));

var twoPrinters = function (d) {
    var [x, y, n] = d;

    var k = Math.ceil(n * x * y / (x + y));
    while (Math.floor(k/x) + Math.floor(k/y) < n) {
        k++;
    }
    return k;
};

var answer = Array.from(Array(size), (v, i) => twoPrinters(data[i]));

console.log(answer.join(" "));

printed = 0
p1,p2,pages = 3, 5, 4
time = 0

while printed != pages:
    time += 1
    if time % p1 == 0:
        printed+=1
        if printed==pages:
            break
    if time % p2 == 0:
        printed+=1

print(time)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char* argv[])
{
    if(argc!=4)
    {
        printf("no argc 4 ! error");
        return 0;
    }

    int bool = 1;
    int a = atoi(argv[1]);
    int b = atoi(argv[2]);
    int c = atoi(argv[3]);  
    int sec = 0;
    int count = 0;
    while(bool)
    {
        sec++;
        if( a<=sec || b<=sec )
        {
            if(sec%a==0||a==1)
            {
                count++;
                if(count==c)
                {
                    bool=0;
                    break;
                }
            }
            if(sec%b==0||b==1)
            {
                count++;
                if(count==c)
                {
                    bool=0;
                    break;
                }
            }
        }

    }
    printf("sec : %d",sec);

    return 0;

}

파이썬 3.6

"""
아이디어>
 1) 두 대의 프린터의 출력 시간이 같을 경우 출력에 걸리는 최소 시간(time)은 X *(N//2) + (N%2)*X 가 됩니다.
 2) 출력시간이 다를 경우 빠른 프린터(min([X,Y]))로 출력한 수량(t)과 느린 프린터(max([X,Y]))로 출력한 수량(q)의 합을 각 시간 별로 체크하여, 
 3) time이 각 프린터의 출력 시간의 배수(t*min([X,Y]) or q*max([X,Y]))에 도래했을때 잔여 수량(N-(t+q))과 출력한 수량(t+q)에 따라 최소 시간이 소요되는 프린터를 선택하여 출력을 이어갑니다.
"""
def inputdata():
    n = int(input(''))
    for i in range(n):
        data.append(input('').split())

def twoprinters(data):
    X,Y,N,time,time_list,t,q = 0, 0, 0, 0, [],0,0
    for i in data:
        X,Y,N = int(i[0]),int(i[1]),int(i[2])
        if X == Y:
            time = X*(N//2)+(N%2)*X
        else:
            while t+q < N:
                time += 1
                if time == 1:
                    t += 1
                    q += 1
                elif time == t*min([X,Y]) and time != q*max([X,Y]):
                    t += 1
                    if t + q == N:
                        if max([X,Y]) // min([X,Y]) > 1:
                            time += min([X,Y])*(max([X,Y]) // min([X,Y])-1)
                        else:
                            time += min([X,Y])
                elif time != t*min([X,Y]) and time == q*max([X,Y]):
                    if (q+1)*max([X,Y]) < (t+1)*min([X,Y]):
                        q += 1
                        if t + q == N:
                            time += max([X,Y])
                    else:
                        time += t*min([X,Y]) - time
                        t += 1
                        if t + q == N:
                            time += min([X,Y])                     
                elif time == t*min([X,Y]) and time == q*max([X,Y]):
                    if t + q == N-2:
                        t += 1
                        q += 1
                        time += max([X,Y])
                    elif t + 1 == N -1:
                        t += 1
                        time += min([X,Y])
                    else:
                        t += 1
                        q += 1
        time_list.append(str(time))
        time,t,q = 0,0,0
    return ' '.join(time_list)

if __name__ == "__main__":
    data = []
    inputdata()
    print("\n""%s"%twoprinters(data))

*결과값

2
1 1 5
3 5 4

3 9

def printer(l):
    if l[2] < l[0]+l[1]:
        for i in range(l[1]+1):
            if not((i+(i*l[0])//l[1]) - l[2]):
                return i*l[0]
        for j in range(l[0]+1):
            if not(j+(j*l[1])//l[0] -l[2]):
                return j*l[1]
            if not(j+(j*l[1])//l[0] -l[2]-1):
                return j*l[1]
    else:
        return printer([l[0],l[1],l[2]%(l[0] + l[1])]) + (l[2]//(l[0] + l[1]))*l[0]*l[1]

1장 인쇄할 때마다 어떤 프린트를 선택해야 하는가에 초점을 두고 풀었습니다.

    def twoPrinters(print1:Int, print2:Int, N:Int):Int = {
      def step(idx1:Int, idx2:Int, n:Int, ans:Int):Int = {
        n match {
          case 0 => ans
          case x if print1*idx1 <= print2*idx2 => step(idx1+1, idx2, n-1, print1*idx1)
          case x if print1*idx1 > print2*idx2 => step(idx1, idx2+1, n-1, print2*idx2)
        }
      }
      step(1, 1, N, 0)
    }
    println(twoPrinters(1, 1, 5))

// 자바입니다
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();

        for (int i=0; i<t; i++) {
            int x = sc.nextInt();
            int y = sc.nextInt();
            int n = sc.nextInt();

            int a = 0;
            int b = 0;
            int cnt = 0;
            while(cnt < n) {
                a++;
                b++;
                if (a % x == 0)
                    cnt++;
                if (b % y == 0)
                    cnt++;
            }
            System.out.println(Math.min(a, b));
        }
    }
// while문 찍어보니까 Math.min 필요 없겠네용

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

class Printer{
    int velocity;
    int count;

    Printer(int v){
        this.velocity = v;
        this.count = 0;
    }
}
public class TwoPrinters {

    public static int execute(int x, int y, int n){
        int result = 0; // 걸린시간

        Printer p1 = new Printer(x);
        Printer p2 = new Printer(y);

        while(n > 0){
            result++;
            if(result % p1.velocity == 0){
                p1.count++;
                n--;
            }
            if(result % p2.velocity == 0){
                p2.count++;
                n--;
            }

        }
        return result;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);

        int testCase = sc.nextInt();

        List<Integer> resultList = new ArrayList<>();

        for(int i=0; i<testCase; i++){
            int x = sc.nextInt();
            int y = sc.nextInt();
            int n = sc.nextInt();

            resultList.add(execute(x, y, n));

        }
        for(int i : resultList){
            System.out.print(i + " ");
        }


    }

}

import java.util.Scanner;

public class TwoPrinters {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int b = sc.nextInt();
        int[] d = new int[b];
        for (int i = 0; i < b; i++)
            d[i] = c(sc.nextInt(), sc.nextInt(), sc.nextInt());
        for (int i = 0; i < b; i++)
            System.out.print(d[i] + " ");
    }

    private static int c(int x, int y, int z) {
        int count = x * z;
        for (int i = 0; i < z; i++)
            for (int j = 0; j < z; j++)
                if (z == i + j)
                    count = count > (i * x > j * y ? i * x : j * y) ? (i * x > j * y ? i * x : j * y) : count;
        return count;
    }
}

print_time = lambda x,y,n: sorted(list(range(x,x*n+1,x))+list(range(y,y*n+1,y)))[n-1]
print(print_time(1,1,5))

먼저 X, Y 중에서 효율이 좋은 녀석만으로 인쇄하는 시간을 계산하고,

한 페이지씩 빼 가면서 효율 나쁜 프린터에 맡깁니다.

tX (X가 쓴 시간), tY (Y가 쓴 시간)가 교차할 떄까지.

tX, tY 중 큰 쪽: max(tX, tY) 이 현재 상태에서 걸리는 시간이 되고,

교차한 직후 상태와 직전 상태 중 시간이 짧은 쪽을 택합니다.

def min_print_time(X, Y, N):
    if X > Y:
        X, Y = Y, X     # X <= Y

    tX, tY = X * N, 0
    while tX > tY:
        tX -= X
        tY += Y

    return min(max(tX, tY), max(tX + X, tY - Y))


input_data = "2\n1 1 5\n3 5 4"
for line in input_data.split('\n')[1:]:
    X, Y, N = map(int, line.split())
    print(min_print_time(X, Y, N), end=' ')

C#

A 프린터(X초/페이지 출력), B 프린터(Y초/페이지 출력) 및 총 페이지 수 N에 대해,
A 프린터, B 프린터가 각각 출력 가능한 페이지를 a, b라고 한다: (N = a + b)

최소의 시간은 두 프린터의 출력 시간이 같아 질 때이므로,
A 프린터 출력시간 (= a * X) = B 프린터 출력시간 (= b * Y = (N - a) * Y)
즉,
a = N * Y / (X + Y),
b = N * X / (X + Y)

출력 페이지는 정수여야 하므로, a, b의 계산값을 정수화(버림)한 값을 각각 ai, bi라고 하면,
출력에 걸린 시간은 Max(ai * X, bi * Y) 이다. ...... Eq.1

이 때, 남는 페이지를 Nr = N - (ai + bi) (Nr >= 0인 정수)라고 하면
남은 페이지에 대해 추가되는 시간은 Nr * Min(X, Y) 이다. ...... Eq.2 < Max(X, Y)

따라서, 최소 소요 시간은 Eq.1 + Eq.2에 의해 구할 수 있다.

using System;
using System.Linq;
using System.Text;

namespace CD062
{
    class Program
    {
        static void Main()
        {
            int numCases = int.Parse(Console.ReadLine());
            var result = new StringBuilder();
            for (int i = 0; i < numCases; i++)
            {
                var inputs = Console.ReadLine().Split(' ').Select(s=>int.Parse(s)).ToArray();
                int X = inputs[0];
                int Y = inputs[1];
                int N = inputs[2];
                result.Append($"{GetPrintTime(X, Y, N)} ");
            }
            Console.WriteLine(result);
        }

        static int GetPrintTime(int X, int Y, int N)
        {
            int ai = N * Y / (X + Y);
            int bi = N * X / (X + Y);
            int Nr = N - (ai + bi);

            return Math.Max(ai * X, bi * Y) + Nr * Math.Min(X, Y);
        }
    }
}

from math import gcd

def two_printers(x,y,n):
    xc,yc,i,t = x,y,gcd(x,y),0
    while n  > 0:
        xc,yc,t = xc-i,yc-i,t+i
        if xc == 0:
            n -= 1
            xc = x
        if yc == 0:
            n -= 1
            yc = y
    return t

def f(m, n, p):
    k = 0
    while p > 0:
        k += 1
        if k%m == 0:
            p -= 1
        if k%n == 0:
            p -= 1        
    print(k)


n = int(input('input data: \n'))
L = []
for i in range(n):
    m, n, p = map(int, input().split())
    L.append([m, n, p])

print('\nanswer:')
for _list in L:
    m, n, p = _list
    f(m, n, p)

input data: 
2
1 1 5
3 5 4

answer:
3
9

tn=int(input("input data:\n"));ans=''

for i in range(tn):
    x,y,n= map(int,input().split());(nx,ny)=(0,0)
    if x>y:
        (x,y)=(y,x)

    while 1:
         nx+=1
         if nx+ny==n:
             break

         if nx*x>=(ny+1)*y:
             ny+=1

    ans+=str(nx*x)+' '

print("answer:\n"+ans)

파이썬 3.7입니다.

import math
n=int(input('number of cases : '))
printer=[]
result=[]

for i in range(n):
    printer.append(input("case: "))

for i in printer:
    case=list(map(int,i.split()))
    pages=0
    time=0
    while pages<case[2]:
        time=time+1
        pages=math.floor(time/case[0])+math.floor(time/case[1])
        print(pages,time/case[0],time/case[1])
    result.append(time)

print(result)

test=int(input("테스트 케이스: "))
result=[]
for i in range(1,test+1):
    x,y,n=input("XYN: ").split(' ')
    x,y,n=(int(x),int(y),int(n))
    temp=min([x,y])
    start_x=x
    start_y=y
    time=0
    page=0
    while True:
       time=time+temp
       page+=1
       x=x-temp
       y=y-temp
       if x==0:
          x=start_x
       elif y==0:
          y=start_y
       temp=min([x,y])
       if page==n:
          break
    result.append(time)
print(result,end=' ')
print(' ')

def Two_Print(x,y,n):
    i = 1
    while True :
        if i//x + i//y >= n :
            print(i)
            break
        else :
            i += 1

case = int(input("테스크 케이스 : "))        

for i in range(case):
    data = (input("첫번째 두번째 소유시간  : "))
    x,y,n =map(int, data.split(" "))
    Two_Print(x,y,n)

import java.util.*;
public class TwoPrinters {

    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);
        int times = Integer.parseInt(scan.nextLine());
        ArrayList<String> list_str =  new ArrayList<String>();
        for(int i=0; i<times; i++) {
            list_str.add(scan.nextLine());
        }
        ArrayList<Integer> list = new ArrayList<Integer>();
        for(int j=0; j<list_str.size(); j++) {
            String[] parse = list_str.get(j).split(" ");
            for(int i=0; i<parse.length; i++) {
                list.add(Integer.parseInt(parse[i]));
            }
        }
        for(int i=0; i<list.size(); i=i+3) {
            int X = list.get(i);
            int Y = list.get(i+1);
            int N = list.get(i+2);
            int count = 0;
            for(int j=1;;j++) {
                if(j%list.get(i)==0) {
                    count++;
                }
                if(j%list.get(i+1)==0) {
                    count++;
                }
                if(count>=list.get(i+2)) {
                    System.out.print(j+" ");
                    break;
                }
            }
        }
    }
}

def main(N,M,A,C,K):
    if C >= A:
        return K
    C +=1 
    C1 = A-C
    N1 = N * C
    M1 = M * C1
    if N1 > M1:
        K.append(N1)
    if N1 < M1:
        K.append(M1)
    return main(N,M,A,C,K)

mainlist = list()
N = int(input())
for i in range(N):
    Nlist = list(map(int,input().split()))
    k = list()
    mainlist.append(min(main(Nlist[0],Nlist[1],Nlist[2],0,k)))
final = ""
for i in range(len(mainlist)):
    final = final + str(mainlist[i]) +" "
print(final)

def print_page(s, l, n):
    s_p, l_p, p, sec = 0, 0, 0, 0
    if n == 1:
        return s
    else:
        while p != n:
            sec += 1
            if sec % s == 0:
                s_p += 1
            if (sec % l == 0) and (s_p + l_p != n):
                l_p += 1
            p = s_p + l_p

    return s_p * s if (s_p * s) >= (l_p * l) else l_p * l


def main():
    x, y, n = 1, 1, 5
    if x >= y:
        short = y
        long = x
    else:
        short = x
        long = y
    print(print_page(short, long, n))

if __name__ == '__main__':
    main()

test_list = []
result_str = ''

test_cnt = int(input('How many test do you want to do? '))

for i in range(test_cnt):
    result_list = []
    test_list.append(list(map(int, input('A printer speed, B printer speed, Paper Volume: ').split())))

    j = 0
    while j <= test_list[i][2]:
        result_list.append(max(test_list[i][0]*(test_list[i][2]-j), test_list[i][1]*j))
        j += 1

    result_str = result_str + str(min(result_list)) + '  '

print(result_str)

늘 그렇듯 의식의 흐름대로 작성했습니다
이 문제 덕분에 조화평균이란 것을 알게되었는데 이해가 되지는 않는다는 단점이 있네요 ^^;

import math
def twoprinters(x,y,z):
    t = 1
    while True:
        if math.floor(t/x)+math.floor(t/y)>=z:
            return t
        t += 1

def minTime(a,b,c):
    x = 1
    while 1:
        if x//a + x//b >= c:
            print(x)
            break
        x += 1


minTime(1,1,5)
minTime(3,5,4)

def Two_Printers():

  first=int(input("input data :"))

  for_answer=[]

  for i in range(first):

    second=input("input data :")

    seconds=second.split(" ")

    if seconds[0]>seconds[1]:

      no_1=seconds[1]

      no_2=seconds[0]

    else:

      no_1=int(seconds[0])

      no_2=int(seconds[1])

    n=int(seconds[2])

    i=1

    while n>0:

      if i%(no_1)==0:

        n-=1

      if i%(no_2)==0:

        n-=1

      i+=1

    for_answer.append(i-1)

  return for_answer

def printer1(x, sec):
    if sec % x == 0:
        return True

def printer2(y, sec):
    if sec % y == 0:
        return True

def func1(x, y, pages):
    sec = 1
    remain_pages = pages
    while True:
        if printer1(x,sec) and remain_pages != 0:
            remain_pages = remain_pages - 1
            print('Print 1 Activated', sec, remain_pages)
        if printer2(y,sec) and remain_pages != 0:
            remain_pages = remain_pages - 1
            print('Print 2 Activated', sec, remain_pages)
        if remain_pages == 0:
            print('ALL PRINTED in {} sec'.format(sec))
            break
        print('TOTAL TIME : ',sec)
        sec += 1

func1(1,1,5)
func1(3,5,4)

def Printer():
    test = int(input("테스트 개수 : "))
    i=0
    w=[]
    while i<test:
        a=int(input("속도 : "))
        b=int(input("속도 : "))
        c=int(input("페이지 수 : "))
        count=0
        total=0
        while True:
            if total>=c:
                w.append(count)
                break
            count+=1
            if count%a==0 and count%b==0:
                total+=2
            elif count%a==0:
                total+=1
            elif count%b==0:
                total+=1
        i+=1
    for i in w:
        print(i, end=' ')
Printer()

time.sleep 재밌네요

import time

def JnM(x,y,n):
    N=0
    i = 0
    while N<n:
        i+=1
        if i%x==0 and i%y==0:
            N+=1
            print(f'{i}초 (+2)')
        elif i%x==0:
            N+=1
            print(f'{i}초 (+1)')
        elif i%y==0:
            N+=1
            print(f'{i}초 (+1)')    
        else : print(f'{i}초')
        time.sleep(0.3)
    print('-'*10,f'{N}페이지 출력완료\n')

def time(x,y,n):
 import math
 return print(math.ceil( (n) / (1/(x*1.0) + 1/(y*1.0))) )

time(1,1,5)
time(3,5,4)
time(3,5,5)
time(2,3,2)

#codingdojing_two printers
#출력이 되려면 각각 x, y초가 지나야 하므로 몫을 각각 더해서 비교.

n = eval(input('number of papers: '))
answer = []

for i in range(n):
    x, y, N = list(map(int,input('X Y N: ').split()))
    s = 0
    while True:
        s += 1
        if s//x  + s//y >= N: #같지 않고 바로 커버리는 경우 있음 
            answer.append(s)
            break

print('answer: ')
for i in range(len(answer)):
    print(f'{answer[i]}', end = ' ')     

n = int(input("Test Case 개수는?"))
arr =[]
for k in range(n):
    X = int(input("첫번쨰 프린터가 1페이지를 출력하는데 걸리는 시간:"))
    Y = int(input("두번쨰 프린터가 1페이지를 출력하는데 걸리는 시간:"))
    while True:
        N = int(input("출력할 문서의 총 페이지수:"))
        if N<= 1000000000:
            break
    arr.append([X,Y,N])

def min_time1(arr):
    X =arr[0]
    Y =arr[1]
    N =arr[2]
    t=1
    while True:
        if int(1/X*t)+int(1/Y*t)>=N:
            break
        t +=1
    return t

def min_time2(arr):
    for k in arr:
        result= min_time1(k)
        print(result,end=" ")

min_time2(arr)

count = int(input("input data :"))
_input = [list(map(int,input().split())) for i in range(count)]
answer = []

for i in _input:
    time = 0
    _output = 0

    while(_output < i[2]):
        time += 1
        if time % i[0] == 0 : _output += 1
        if time % i[1] == 0 : _output += 1

    answer.append(time)

print("answer :",answer)

def page(a):
    X,Y,N = map(int, a.split(' '))
    return 1+round(N/(1/X+1/Y))

a = '''2
1 1 5
3 5 4'''

print([page(a.split('\n')[i+1]) for i in range(int(a[0]))])

# Python
# 수학적인 계산이 아닌 단순하게
# 실제로 프린터가 출력을 시작한 것처럼 해봤습니다.

def Two_printers(X, Y, N):
    n = 0                   # 현재 출력 한 페이지 수
    seconds = 0             # 현재 소요 된 시간
    while N > n:
        seconds += 1
        if seconds % X == 0:
            n += 1
        if seconds % Y == 0:
            n += 1
    return seconds

// Ugly Number 문제와 유사하게 풀어봤습니다. // 언어는 javascript 입니다.

const solution = (x,y,n) => {

  // n개의 페이지를 출력해야한다
  // 프린터X 는 한 페이지를 출력하는데 x 초 걸린다.
  // 프린터Y 는 한 페이지를 출력하는데 y 초 걸린다.

  // 최소시간 변수
  let result = 0;

  // 만약 x,y 출력시간이 같다면
  if(x===y){
    // 출력해야하는 페이지의 수가 짝수인지에 따라 리턴 후 종료
    return n%2===0?(n/2*x):(((n-1)/2)+1)*x;
  }


  // 프린터X 가 페이지를 출력하는데 걸리는 시간들을 담는 배열
  const arrX = [];

  // 프린터Y 가 페이지를 출력하는데 걸리는 시간들을 담는 배열
  const arrY = [];

  // 출력 할 n 번째 문서 (초기값 1);
  let print = 1;
  while( n > 0 ){
    arrX.push(print*x);
    arrY.push(print*y);

    if(result > arrX[0]){
      arrX.shift();
    }
    if(result > arrY[0]){
      arrY.shift();
    }

    // 두개의 값 중 작은 값을 선택해 출럭시간(result) 에 할당
    result = Math.min(arrX[0], arrY[0]);

    // 할당된 값은 제거
    if(result === arrX[0]){
      arrX.shift();
    }
    if(result == arrY[0]){
      arrY.shift();
    }

    // 총 프린트해야 할 페이지 수 재정비
    n--
    print++;
  }
  // n 개의 페이지를 출력하는 최소 시간을 리턴해라.
  return result;
}

def twoPrinter(x,y,n):
    minVal = y*n
    for i in range(1, n):
        if minVal< max(x*i, y*(n-i)):
            return minVal
        minVal = max(x*i, y*(n-i))
    return minVal

print(twoPrinter(1,1,5))
print(twoPrinter(3,5,4))