파이썬입니다

from itertools import zip_longest

def compare(left, right):
    left_vars = map(int, left.split('.'))
    right_vars = map(int, right.split('.'))
    for a, b in zip_longest(left_vars, right_vars, fillvalue = 0):
        if a > b:
            return '>'
        elif a < b:
            return '<'
    return '='

CASES = [['0.0.2', '0.0.1'],
         ['1.0.10', '1.0.3'],
         ['1.2.0', '1.1.99'],
         ['1.1', '1.0.1']]

if __name__ == '__main__':
    for case in CASES:
        print('{0[0]} {1} {0[1]}'.format(case, compare(*case)))

ver1=str(input("Ver1 입력 :"))
ver2=str(input("Ver2 입력 :"))
ver1=ver1.split(".")
ver2=ver2.split(".")
a=max(len(ver1),len(ver2))
for i in range(a):
    if ver1[i] > ver2[i] :
        print("Ver 1 > Ver 2")
        break
    elif ver1[i] < ver2[i] :
        print("Ver 1 < Ver 2")
        break

Python 3.5.2

def versionCmp(a,b):
    a,b=map(lambda x : map(int, x.split('.')),(a,b))
    return a>b


print versionCmp('0.0.2','0.0.1') 
print versionCmp('1.0.10','1.0.3') 
print versionCmp('1.1.99','1.2.0') 
print versionCmp('1.1','1.0.1') 

라고 작성하였으나... 버그가 있어서 수정하였습니다. 버전 1과 1.0을 다르게 인식하더군요. 또한 버전이 같은 경우를 따로 표시하고, 위 버그를 해결하였습니다. 앞버전이 높으면 1, 같으면 0, 낮으면 -1을 출력합니다.

def versionCmp(a,b):
    a,b=map(lambda x : map(int, x.split('.')),(a,b))
    while len(a)>len(b): b += (0,)
    while len(a)<len(b): a += (0,)
    return cmp(a,b)


print versionCmp('0.0.2','0.0.1') # 1
print versionCmp('1.0.10','1.0.3') # 1
print versionCmp('1.1.99','1.2.0') # -1
print versionCmp('1.1','1.0.1') # 1
print versionCmp('1.0','1.0.0') # 0

C# 입니다.

static char[] separ = { '.' };
const int ERROR = 100;

static void Main(string[] args)
{
    string v1 = "0.0.1", v2 = "0.0.1.0.0.1";    
    switch (CompareVersion(v1, v2))
    {
        case -1: Console.Write(string.Format("{0} < {1}", v1, v2)); break;               
        case 0: Console.Write(string.Format("{0} == {1}", v1, v2)); break;
        case 1: Console.Write(string.Format("{0} > {1}", v1, v2)); break;
        case ERROR: Console.Write("Invalid Version"); break;
    }
}

static int CompareVersion (string v1, string v2)
{           
    string[] v1a = v1.Split(separ, StringSplitOptions.RemoveEmptyEntries);
    string[] v2a = v2.Split(separ, StringSplitOptions.RemoveEmptyEntries);

    if (v1a.Length == 0 || v2a.Length == 0) return ERROR;
    int maxLength = v1a.Length > v2a.Length ? v1a.Length : v2a.Length;

    for (int i = 0; i < maxLength; i++)
    {
        int v1i = 0, v2i = 0;
        if (v1a.Length > i && !int.TryParse(v1a[i], out v1i)) return ERROR;
        if (v2a.Length > i && !int.TryParse(v2a[i], out v2i)) return ERROR;
        if (v1i != v2i) return v1i.CompareTo(v2i);
    }
    return 0;
}

다른 효율적인 방법이 있는지는 모르겠지만, 별다른 기법 없이 문자열 나누고 앞부분부터 하나씩 비교했습니다 공백이 들어가거나, 동일한버전이지만 길이가 다를경우도 문제없이 비교됩니다. 숫자외의 다른 문자열을 넣거나 비어있다면 오류 메시지를 날립니다. 예제의 결과는 v2가 더 크다고 처리됩니다. 혹시나 개행하고 싶다면 그건 기분 탓일겁니다.

파이썬 입니다. 만약 서브 버전이 없는 경우 기본적으로 0 이라는 가정하에 비교하도록 하였습니다.

def CompareVersion (version1, version2) :

    v1 = map(int, version1.split('.'))
    v2 = map(int, version2.split('.'))

    if len(v1) > len(v2):
        v2 += [0] * (len(v1) - len(v2))
    else:
        v1 += [0] * (len(v2) - len(v1))

    for (vv1, vv2) in zip(v1, v2):
        if vv1 > vv2:
            return 1
        elif vv1 < vv2:
            return -1

    return 0

print CompareVersion ('0.0.2',  '0.0.1')
print CompareVersion ('1.0.3',  '1.0.10')
print CompareVersion ('1.2.0',  '1.1.99')
print CompareVersion ('1.1',    '1.0.1')
print CompareVersion ('1.1',    '1.1.0.1')

프로그래밍 공부한지 한달된 왕보초가 짠 코드...

public static void main(String[] args) {
        CodingPractice09 code=new CodingPractice09();
        String version1="1.0.0";
        String version2="1.0.23";
        int[] num1=code.stringToInt(version1);
        int[] num2=code.stringToInt(version2);

        int i=0;
        while(i<Math.min(num1.length, num2.length)) {
            if(num1[i]>num2[i]) {
                System.out.println(version1+">"+version2);
                break;
            }
            if(num1[i]<num2[i]) {
                System.out.println(version1+"<"+version2);
                break;
            }
            if(num1[i]==num2[i])
                i++;
        }
    }

    public int[] stringToInt(String s) {
        String[] arr=s.split("[.]");
        int[] num=new int[arr.length];
        for(int i=0;i<num.length;i++) {
            num[i]=Integer.parseInt(arr[i]);
        }
        return num;
    }

# 한글 처리 in Atom 1.21.1 + Anaconda(Python 3.6.3)
import sys
import io

sys.stdout = io.TextIOWrapper(sys.stdout.detach(), encoding='utf-8')
sys.stderr = io.TextIOWrapper(sys.stderr.detach(), encoding='utf-8')

# A씨는 두 개의 버전을 비교하는 프로그램을 작성해야 한다.
# 버전은 다음처럼 "." 으로 구분된 문자열이다.
# 버전 예) 1.0.0, 1.0.23, 1.1
# 두 개의 버전을 비교하는 프로그램을 작성하시오.
# 다음은 버전 비교의 예이다.
# 0.0.2 > 0.0.1
# # 1.0.10 > 1.0.3
# 1.2.0 > 1.1.99
# 1.1 > 1.0.1

version1 = input("버전을 입력하세요 :").split('.')
version2 = input("버전을 입력하세요 :").split('.')

compare = '='
for i in range(max(len(version1), len(version2))):
    if len(version1) == i:
        version1 += ['0']
    if len(version2) == i:
        version2 += ['0']

    if int(version1[i]) > int(version2[i]):
        compare = '>'
        break
    elif int(version1[i]) < int(version2[i]):
        compare = '<'
        break

print('.'.join(version1), compare, '.'.join(version2))

파이썬 3

def bigger(v1, v2):
    list1 = list(map(int, v1.split(".")))
    list2 = list(map(int, v2.split(".")))

    for i in range(min(len(list1), len(list2))):
        if list1[i] > list2[i]:
            return v1
        elif list1[i] == list2[i]:
            continue
        else:
            return v2

print(bigger("0.0.2", "0.0.1"))
print(bigger("1.0.10", "1.0.3"))
print(bigger("1.2.0", "1.1.99"))
print(bigger("1.1", "1.0.1"))

결과

0.0.2
1.0.10
1.2.0
1.1

#codingdojing_comparisonVersion

a = input('version a: ')
b = input('version b: ')

aList = a.split('.') # ['1', '0', '11']
bList = b.split('.') # ['1', '0']

#리스트를 비교한다. str 으로 그냥 하면 

if aList > bList:
    print(f'{a} > {b}')
elif aList < bList:
    print(f'{a} < {b}')
else:
    print('same version')

v_1=input().split('.')
v_2=input().split('.')

if v_1[2] > v_2[2] and v_1[1] > v_2[1] and v_1[0] > v_2[0]:
    print('>')
else:
    print('<')

java입니다. 출제자님 문제상의 예외사항이 있어 추가하여 구현해보았습니다.

import java.util.Scanner;

public class version_comp {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String v1, v2, tmp;
        String[] v1_arr, v2_arr;
        String in_param[];

        while(true){
            System.out.println("Input compared version : ");
            v1 = sc.nextLine();
            if(v1.length() != 0)
            {
                v1_arr = v1.split("[.]");
                break;
            }
            else
            {
                System.out.println("Invalid value!!");
            }
        }

        while(true){
            System.out.println("Input comparing version : ");
            v2 = sc.nextLine();
            if(v2.length() != 0)
            {
                v2_arr = v2.split("[.]");
                break;
            }
            else
            {
                System.out.println("Invalid value!!");
            }
        }

        switch (compare(v1_arr, v2_arr)) {
        case 0:
            System.out.println(v1+" < "+v2);
            break;

        case 1:
            System.out.println(v1+" > "+v2);
            break;

        case -1:
            System.out.println(v1+" == "+v2);
            break;
        }
    }

    static int compare(String[] v1, String[] v2)
    {
        int ret = -1;

        for(int i = 0 ; i < v1.length ; i++){
            if(v2.length-1 >= i)
            {
                if(Integer.parseInt(v1[i]) < Integer.parseInt(v2[i]))
                {
                    ret = 0;
                    break;
                }
                else if(Integer.parseInt(v1[i]) > Integer.parseInt(v2[i]))
                {
                    ret = 1;
                    break;
                }   
            }
            else
                ret = 1;
        }

        if(v1.length < v2.length)
            ret = 0;

        return ret;
    }
}

파이썬 2.7


v1 = '0.1.2'
v2 = '0.2'

size = len(v1)

for i in range(size):
    if v1[i] > v2[i]:
        recent_ver = v1
        break
    elif v1[i] < v2[i]:
        recent_ver = v2
        break
    else:
        continue

print 'recent version : ', recent_ver

v1 = '1.2.0'
v2 = '1.1.99'

v1_array = v1.split('.')
v2_array = v2.split('.')

for x in range(len(v1_array)):
    if int(v1_array[x]) > int(v2_array[x]):
        print(v1 + ' > ' + v2)
        break
    elif int(v1_array[x]) < int(v2_array[x]):
        print(v2 + ' > ' + v1)
        break

Tcl/tk입니다. 이렇게 해도 되나 모르겠네요^^;

proc ver_check {a b} {
    set i "$a $b"
    set oldVer  [ lindex [ lsort -dictionary -increasing $i ] 0 ]
    set lastVer [ lindex [ lsort -dictionary -increasing $i ] 1 ]   
    puts "$lastVer > $oldVer"
}
ver_check 1.1 1.0.1

PHP 입니다.

function compVersion ($a, $b) {
    if (!$a || !$b) {
        echo "Need 2 version value for compare";
    }

    $arrA = explode(".", $a);
    $arrB = explode(".", $b);

    $max = sizeof($arrA);
    for ($i = 0; $i < $max; $i++) {
        if ($arrA[$i] == $arrB[$i]) {
            continue;
        }
        if ($arrA[$i] > $arrB[$i]) {
            echo $a . " > " . $b;
            return;
        }
        if ($arrA[$i] < $arrB[$i]) {
            echo $a . " < " . $b;
            return;
        }
    }
    if (sizeof($arrB) > $max) {
        echo $a . " < " . $b;
        return;
    }
    echo $a . " = " . $b;
}

compVersion ("0.0.2", "0.0.1");
compVersion ("1.0.10", "1.0.3");
compVersion ("1.2.0", "1.1.99");
compVersion ("1.1", "1.0.1");
compVersion ("1.1", "1.1.1");

Swift 입니다.

import Foundation

extension String {
    public func biggerThan(s2: String) -> Bool {
        let s1Array = self.componentsSeparatedByString(".").map { Int($0)! }
        let s2Array = s2.componentsSeparatedByString(".").map { Int($0)! }
        return zip(s1Array, s2Array).map { $0.0 > $0.1 }.reduce(false) { $0 || $1 }
    }
}

let v1 = "1.1"
let v2 = "1.0.1"

let op: String

if v1 == v2 {
    op = "=="
}
else if (v1.biggerThan(v2)) {
    op = ">"
}
else {
    op = "<"
}

print("\(v1) \(op) \(v2)")

def ver_comp(ver1, ver2):
    pgm1 = ver1.split(".")
    pgm2 = ver2.split(".")
    if len(pgm1) > len(pgm2):
        comp_length = len(pgm1)
        for i in range(len(pgm1)-len(pgm2)):
            pgm2.append("0")
    elif len(pgm1) < len(pgm2):
        comp_length = len(pgm2)
        for i in range(len(pgm2)-len(pgm1)):
            pgm1.append("0")
    else :
        comp_length = len(pgm1)
    opr = "?"    
    for i in range(comp_length):
        if int(pgm1[i]) > int(pgm2[i]):
            opr = ">"
            break
        elif int(pgm1[i]) < int(pgm2[i]):
            opr = "<"
            break
        else:
            opr = "="

    print (ver1, opr, ver2)

ver_comp("0.0.2", "0.0.1")
ver_comp("1.0.10", "1.0.3")
ver_comp("1.2.0", "1.1.99")
ver_comp("1.1", "1.0.1")

python 3.4

a1='0.0.2'.split('.')
a2='0.0.1'.split('.')

if a1 > a2 :
    print(a1,'>',a2)
else:
    print(a2,'.',a1)

Java 입니다. 정규식을 이용해서 입력값의 형식을 지정했습니다.

import java.util.Scanner;

public class VersionCompareVer3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[][] str = new String[2][];
        String tmp1,tmp2,reg="^\\d+(\\.\\d+)*$";
        int i=0;

        while(true){
            System.out.print("write var1 :");
            tmp1=sc.next();
            if(tmp1.matches(reg)){
                str[0]=tmp1.split("\\.");
                break;
            }//end if
        }//end while loop

        while(true){
            System.out.print("write var2 :");
            tmp2=sc.next();
            if(tmp2.matches(reg)){
                str[1]=tmp2.split("\\.");
                break;
            }//end if
        }//end while loop

        int compareLength=str[0].length>=str[1].length?str[1].length:str[0].length;

        boolean check1=Integer.parseInt(str[0][i])>Integer.parseInt(str[1][i]);
        boolean check2=Integer.parseInt(str[0][i])<Integer.parseInt(str[1][i]);
        boolean check3=Integer.parseInt(str[0][i])==Integer.parseInt(str[1][i]);
        boolean check5=str[0].length>str[1].length;
        boolean check6=str[0].length<str[1].length;
        boolean check7=str[0].length==str[1].length;

        for(i=0;i<compareLength;i++){
            boolean check4=(i+1)==compareLength;
            if ((check3&&check4&&check5)||check1){
                System.out.println(tmp1+" > "+tmp2);
                break;
            } else if ((check3&&check4&&check6)||check2){
                System.out.println(tmp1+" < "+tmp2);
                break;
            } else if (check3&&check4&&check7){
                System.out.println(tmp1+" = "+tmp2);
                break;
            }
        }//end compare forloop  

        sc.close();
    }//end main
}//end class

파이썬 배운지 1달이라 배운 실력대로 짜보았습니다.

a="0.5.2"
b="0.7.1"

if a[0] > b[0]:
    print a, ">", b

elif a[0] <b[0]:
    print a, "<", b

else:
    if a[2]>b[2]:
        print a, ">",b
    elif a[2]<b[2]:
        print a, "<", b
    else:
        if a[4]>b[4]:
            print a, ">",b
        elif a[4]<b[4]:
            print a, "<",b

Ruby

ver = ->str { str.split('.').map &:to_i }
compare = ->a,b { [a, "=><"[ ver.(a)<=>ver.(b) ], b]*' ' }

Test

expect( compare['0.0.2', '0.0.1'] ).to eq "0.0.2 > 0.0.1"
expect( compare['1.0.10', '1.0.3'] ).to eq "1.0.10 > 1.0.3"
expect( compare['1.2.0', '1.1.99'] ).to eq "1.2.0 > 1.1.99"
expect( compare['1.1', '1.0.1'] ).to eq "1.1 > 1.0.1"
expect( compare['1.1.0','1.1.0'] ).to eq "1.1.0 = 1.1.0"
expect( compare['1.1.99','1.2.0'] ).to eq "1.1.99 < 1.2.0"

#coding: CP949
n=input('비교할 버전을 입력하라:')
m=input('하나 더 입력하라:')

N=n.split('.')
M=m.split('.')
i=0
while i <= 2:
    if int(N[i]) > int(M[i]):
        print(eval('n')+'>'+eval('m'))
        break
    elif int(N[i]) == int(M[i]):
        i+=1
    else:
        print(eval('n')+'<'+eval('m'))
        break
if i == 3:
    print(eval('n')+'='+eval('m'))

두 버전이 같은 경우까지 고려하였스비다.
파이썬 3.3

python 3.5

def comparison_version(version1, version2):
    ver1 = [int(i) for i in (str(version1)).split('.')]
    ver2 = [int(i) for i in (str(version2)).split('.')]
    length = min(len(ver1), len(ver2))
    for i in range(length):
        if ver1[i] != ver2[i]:
            if ver1[i] > ver2[i]:
                return print(version1 + ">" + version2)
            else:
                return print(version1 + "<" + version2)
    if len(ver1) != len(ver2):
        if length == len(ver1):
            return print(version1 + "<" + version2)
        else:
            return print(version1 + ">" + version2)
    else:
        return print(version1 + "==" + version2)



comparison_version('0.0.2', '0.0.1')
comparison_version('1.0.10', '1.0.3')
comparison_version('1.2.0', '1.1.99')
comparison_version('1.1', '1.0.1')
comparison_version('2.3.1', '2.3.1')

파이썬3.4입니다.

while True:
    a = input('1: ')
    b = input('2: ')
    a_ = a.split('.')
    b_ = b.split('.')
    for i in range(3):
        if int(a_[i]) > int(b_[i]):
            print('{} > {}'.format(a, b))
            break
        elif int(a_[i]) < int(b_[i]):
            print('{} < {}'.format(a, b))
            break

Swift 2.2 입니다.

let cases:Array<(String, String)> = [
    ("0.0.2", "0.0.1"),
    ("1.0.10", "1.0.3"),
    ("1.2.0", "1.1.99"),
    ("1.1", "1.0.1")
]

func compareVersion(xs:(String, String)) -> String
{
    let destruct:(String) -> [Int] = { x in 
        x.characters.split(".").map{ Int(String($0))! } }
    let (m, n) = xs
    let ms = destruct(m)
    let ns = destruct(n)
    for i in 0...max(ms.count, ns.count) {
        let x = i < ms.count ? ms[i] : -1
        let y = i < ns.count ? ns[i] : -1
        if x != y {
            return "\(xs.0) \(x > y ? ">" : "<") \(xs.1)"
        }
    }
    return "\(xs.0) = \(xs.1)"
}

cases.forEach{print(compareVersion($0))}

저렇게 해놓고 보니까 파이썬에도 똑같이 가서 그닥 라인수가 줄지는 않네요. zip_longest를 쓰면 좀 더 간단할 것 같습니다.

data = '''0.0.2 0.0.1
1.0.10 1.0.3
1.2.0 1.1.99
1.1 1.0.1'''.split('\n')

def do(line):
    a, b = line.split()[:2]
    ax, bx = [[int(i) for i in x.split('.')] for x in line.split()][:2]
    l = max(len(ax), len(bx))
    for i in range(0, l):
        x = ax[i] if i < len(a) else -1
        y = bx[i] if i < len(b) else -1
        if x > y:
            c = '>'
            break
        elif x < y:
            c = '<'
            break
    else:
        c = '='
    return "{} {} {}".format(a, c, b)

for d in data:
    print(do(d))

from itertools import zip_longest

data = '''0.0.2 0.0.1
1.0.10 1.0.3
1.2.0 1.1.99
1.1 1.0.1'''.split('\n')

def do2(line):
    a, b = line.split()[:2]
    ax, bx = [[int(i) for i in x.split('.')] for x in line.split()][:2]
    for x, y in zip_longest(ax, bx, fillvalue=-1):
        if x > y: return a + " > " + b
        elif x < y: return a + " < " + b
    return a + " = " + b


for d in data:
    print(do2(d))

Python 2.7

파이썬은 리스트끼리 비교할 수 있습니다.

s1 = raw_input()
s2 = raw_input()
a1 = map(int, s1.split('.'))
a2 = map(int, s2.split('.'))
print s1, '=><'[cmp(a1, a2)], s2

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

char* get_latest_version(char*, char*);

void main() {

        char* ver1[80]={0};
        char* ver2[80]={0};

        while(1) {
                printf("input version1 : ");
                gets(ver1);
                if(!strcmp(ver1,"exit")) exit(0);
                printf("input version2 : ");
                gets(ver2);
                if(!strcmp(ver2,"exit")) exit(0);


                printf("\n Highest Version is, %s \n\n",get_latest_version(ver1, ver2));
        }

}

char* get_latest_version(char* ch1, char* ch2) {
        char* result = "None. They are same";
        char versions[2][80];
        int numbers[2][80];
        int i,j;
        int len[2]={0};
        char* tok;

        strcpy(versions[0], ch1);
        strcpy(versions[1], ch2);

        for(i=0; i<2; i++) {
                tok = strtok(versions[i], ".");
                while(tok!=NULL) {
                        numbers[i][len[i]++]=atoi(tok);
                        tok=strtok(NULL, ".");
                }
        }

        i=0, j=0;

        while(len[0] >i && len[1] >j) {
                if(numbers[0][i] > numbers[1][j])
                        return ch1;
                else if(numbers[0][i] < numbers[1][j])
                        return ch2;
                else
                        i++, j++;
        }

        if(len[0]>len[1])
                return ch1;
        else if(len[0]<len[1])
                return ch2;
        return result;
}

자바입니다. string을 "."로 쪼개서 string 배열을 만든 후에, string -> int로 만들어서 비교한 코드입니다.

public String compareVer(String ver1, String ver2){
        String[] ver1_array = ver1.trim().split("[.]");

        String[] ver2_array =  ver2.trim().split("[.]");

        String result = "";
        int test = Math.min(ver1_array.length , ver2_array.length);
        for(int i = 0 ; i < Math.min(ver1_array.length , ver2_array.length);i++){
            if( Integer.parseInt(ver1_array[i]) > Integer.parseInt(ver2_array[i])){
                result = ver1 + " > " + ver2;
                System.out.println(result);
                return result;

            }
        }
        result = ver1 +" < " + ver2;;
        System.out.println(result);

        return result;


    }

from itertools import zip_longest
while __name__ == '__main__':
    for x in ['A','B']:exec(x+'=list(int(x) for x in input("'+x+': ").split("."))')
    for x, y in zip_longest(A, B, fillvalue = 0):
        c = (lambda a,b:'' if a==b else('A' if a>b else 'B'))(x,y)
        if c != '':print(c);break
    else:print('=')

파이썬 3.5.1 64

Python

example = [("0.0.2", "0.0.1"),
           ("1.0.10", "1.0.3"),
           ("1.2.0", "1.1.99"),
           ("1.1", "1.0.1")]

def version(ver):
    major = ver.split(".")[0]
    minor = ver.split(".")[1]
    try:
        micro = ver.split(".")[2]
    except IndexError:
        micro = 0

    major = int(major) * 100000 + int(minor) * 1000 + int(micro)
    return major

for case in example:
    ver1 = version(case[0])
    ver2 = version(case[1])

    if ver1 > ver2:
        print(case[0], " > ", case[1])
    elif ver1 < ver2:
        print(case[0], " < ", case[1])
    else:
        print(case[0], " == ", case[1])

#파이썬3.5.1
def ver(ver1:str,ver2:str) -> bool: #ver1이 더 최신이면 True, ver2가 더 최신이면 False, 두 버전이 똑같으면 no return
    ver1 = ver1.split('.')
    ver2 = ver2.split('.')
    ver1.extend(['0'] * (max([len(ver1), len(ver2)]) - len(ver1)))
    ver2.extend(['0'] * (max([len(ver1), len(ver2)]) - len(ver2)))
    for i in range(len(ver1)):
        if int(ver1[i]) > int(ver2[i]):
            return True
        elif int(ver1[i]) < int(ver2[i]):
            return False

print(ver(input('ver1 : '), input('ver2 : ')))

파이썬입니다

def vcmp(ver1str, ver2str):
        ver1 = ver1str.split('.')
        ver2 = ver2str.split('.')

        i=0
        while ver1[i]==ver2[i]: i+=1
        if int(ver1[i]) > int(ver2[i]): return 1
        else: return 0

ver1 = raw_input("Enter first version : ")
ver2 = raw_input("Enter second version : ")

if vcmp(ver1,ver2): print ver1+" > "+ver2
else : print ver1+" < "+ver2

C#으로 작성했습니다.

using System.Linq;

    public static class Question097CompareVersions
    {

        public static void Answer()
        {
            var output1 = CompareVersions("0.0.2", "0.0.1");
            var output2 = CompareVersions("1.0.10", "1.0.3");
            var output3 = CompareVersions("1.2.0", "1.1.99");
            var output4 = CompareVersions("1.1", "1.0.1");
        }

        public static string CompareVersions(string input1, string input2)
        {
            var split1 = input1.Split('.').ToList();
            var split2 = input2.Split('.').ToList();
            while (split1.Count() > 0 && split2.Count() > 0)
            {
                if (int.Parse(split1.First()) > int.Parse(split2.First())) return input1;
                if (int.Parse(split1.First()) < int.Parse(split2.First())) return input2;
                split1.RemoveAt(0);
                split2.RemoveAt(0);
            }
            return split1.Count() > split2.Count() ? input1 : input2;
        }

    }

자바로 코딩

1 두 버전을 비교
2 두 버전 split
3 두 버전 비교 , 길이가 작은 길이 구함
4 for 돌면서 두 배열을 비교 , 두 숫자가 같이 않으면 체크

    public static void main(String[] args){

        String preVersion   = "";
        String postVersion  = "";

        Scanner sc = new Scanner(System.in);

        System.out.print("첫번째 버전 :: ==> ");
        preVersion = sc.next();

        System.out.print("두번째 버전 :: ==> ");
        postVersion = sc.next();

        System.out.println( isVersion(preVersion , postVersion) );

        sc.close();
    }   

    public static String isVersion(String preVersion , String postVersion){

        String[] pre  = preVersion.split("\\.");
        String[] post = postVersion.split("\\.");
        int len = 0;

        String chk = "";

        len =  (pre.length > post.length) ? pre.length : post.length;

        for(int i=0; i<len; i++){
            int preNum  = Integer.parseInt(pre[i]);
            int postNum =  Integer.parseInt(post[i]);

            if( preNum != postNum ){
                if( preNum > postNum ){
                    chk = "1";
                }else{
                    chk = "2";
                }

                break;
            }
        }

        return "1".equals(chk) ? new String(preVersion + " > " + postVersion)   : new String(preVersion + " < " + postVersion);

    }

    public static void main(String[] args) {
        String result1, result2;
        String version1 = "0.1.2";
        String version2 = "0.1.11";
        StringTokenizer stok1 = new StringTokenizer(version1,".");
        StringTokenizer stok2 = new StringTokenizer(version2,".");
        while(true){
            result1 = stok1.nextToken();
            result2 = stok2.nextToken();
            if(result1.equals(result2)) continue;
            else{
                int num1 = Integer.parseInt(result1);
                int num2 = Integer.parseInt(result2);
                System.out.println(num1>num2 ? version1+">"+version2 : 
                                                version1+"<"+version2);
                break;

            }
        }

    }

public static void main(String[] args){ String first = "1.1.0"; String second = "1.0.23"; String[] ver1 = first.split("\."); String[] ver2 = second.split("\.");

    for(int i = 0; i < 3; i++){
        if(ver1[i].equals(ver2[i])) continue;
        else if(Integer.parseInt(ver1[i]) > Integer.parseInt(ver2[i])) {
            System.out.println(first + " 버전이 " + second + " 버전보다 상위 버전입니다.");
            break;
        }
        else {
            System.out.println(second + " 버전이 " + first + " 버전보다 상위 버전입니다.");
            break;
        }
    }
}```{.java}

public static void main(String[] args){ String first = "1.1.0"; String second = "1.0.23"; String[] ver1 = first.split("\."); String[] ver2 = second.split("\.");

    for(int i = 0; i < 3; i++){
        if(ver1[i].equals(ver2[i])) continue;
        else if(Integer.parseInt(ver1[i]) > Integer.parseInt(ver2[i])) {
            System.out.println(first + " 버전이 " + second + " 버전보다 상위 버전입니다.");
            break;
        }
        else {
            System.out.println(second + " 버전이 " + first + " 버전보다 상위 버전입니다.");
            break;
        }
    }
}

```

av = '1.1'
bv = '1.0.1'
a = av.split('.')
b = bv.split('.')

for i in range(len(a)):
    if int(a[i]) > int(b[i]):
        print av, '>', bv
        break
    elif int(a[i]) < int(b[i]):
        print bv, '>', av
        break

class Ver():
    def __init__(self, version):
        self._ver = version
        self.version = tuple(int(x) for x in self._ver.split('.'))
    def __lt__(self, other):
        return self.version < other.version
    def ___le__(self, other):
        return self.version <= other.version
    def __eq__(self, other):
        return self.version == other.version
    def __ne__(self, other):
        return self.version != other.version
    def __gt__(self, other):
        return self.version > other.version
    def __ge__(self, other):
        return self.version >= other.version
    def __str__(self):
        return self._ver

print('0.0.2 > 0.0.1 : %s' % (Ver('0.0.2') > Ver('0.0.1')))
print('1.0.10 > 1.0.3 : %s' % (Ver('1.0.10') > Ver('1.0.3')))
print('1.2.0 > 1.1.99 : %s' % (Ver('1.2.0') > Ver('1.1.99')))
print('1.1 > 1.0.1 : %s' % (Ver('1.1') > Ver('1.0.1')))
print('0.0.2 < 0.0.1 : %s' % (Ver('0.0.2') < Ver('0.0.1')))
print('0.0.2 <= 0.0.1 : %s' % (Ver('0.0.2') <= Ver('0.0.1')))
print('0.0.2 == 0.0.1 : %s' % (Ver('0.0.2') == Ver('0.0.1')))
print('0.0.2 != 0.0.1 : %s' % (Ver('0.0.2') != Ver('0.0.1')))
print('0.0.2 > 0.0.1 : %s' % (Ver('0.0.2') > Ver('0.0.1')))
print('0.0.2 >= 0.0.1 : %s' % (Ver('0.0.2') >= Ver('0.0.1')))

Python 3.5.2에서 작성하였습니다.

Haskell로 Version 타입을 만들어서 크기 비교를 할 수 있게 Ord 인스턴스를 추가했습니다.

data Version = Version String deriving (Eq, Show, Read)

instance Ord Version where
  compare (Version a) (Version b) = comparing (map readInt. splitOn ".") a b
    where readInt s = read s :: Int

#python 2.7.xxx

from itertools import izip_longest
version1,version2 = "1.1.1","1.1.9"
result = map(lambda x :int(x[0]) - int(x[1]),list(izip_longest(version1.split("."),version2.split("."),fillvalue=0)))
for x in result:
    if x > 0:
        print "{} > {}".format(version1,version2);break
    elif x < 0:
        print "{} < {}".format(version1,version2);break

$input = "1.2.0,1.1.99";

$target = explode(",",$input);
if($target[0] == $target[1]) exit;
$target1 = explode(".",$target[0]);
$target2 = explode(".",$target[1]);

if(count($target1) !=  count($target2)){
    $small = (count($target2) < count($target2)) ? '1' : '2';
    $aTmp = array_fill(0,abs(count($target1)-count($target2)),'0');
    ${'target'.$small} = array_merge(${'target'.$small}, $aTmp);
}


foreach($target1 as $key => $ver){
    if($target1[$key] != $target2[$key]) {
        $result =  ($target1[$key] > $target2[$key]) ? '>' : '<';
        break;
    }
}

echo sprintf("%s %s %s",$target[0],$result,$target[1]);
exit;

test_a = ['0.0.2','1.0.10','1.2.0','1.1']
test_b = ['0.0.1','1.0.3','1.1.99','1.0.1']
for x in range(len(test_a)):
    a = list(map(int,test_a[x].split('.')))
    b = list(map(int,test_b[x].split('.')))
    for y in range(3):
        if a[y] > b[y]:
            print(test_a[x]+' > '+test_b[x])
            break
        elif a[y] < b[y]:
            print(test_a[x]+' < '+test_b[x])
            break

#### 2017.01.20 D-398 ####

def ver(data1,data2):
    data1=(data1).split(".")
    data2=(data2).split(".")
    for i in range(3):
        if data1[i]>data2[i]:
            a=">"
            break
        elif data1[i]<data2[i]:
            a="<"
            break
        a="="
    print(".".join(data1)+" "+a+" "+".".join(data2))
ver("1.2.0","1.0.99")

def compare_version(A, B):
    a = A.split('.')
    b = B.split('.')

    if a > b:
        return A + ' > ' + B
    elif a < b:
        return  A + ' < ' + B
    else:
        return A + ' = ' + B

print compare_version('0.0.2', '0.0.1')
print compare_version('1.0.10', '1.0.3')
print compare_version('1.2.0', '1.1.99')
print compare_version('1.1', '1.0.1')

python에서 list 끼리 바로 비교가 가능하다는 점을 이용했는데 이렇게 해보니까 1.0.10 보다 1.0.3이 더 크게 나오네요.

def compare_version(A, B):
    a = A.split('.')
    b = B.split('.')

    if len(a) == len(b):
        for x in range(0,len(b)):
            if int(a[x]) > int(b[x]):
                return A + ' > ' + B
            elif int(a[x]) < int(b[x]):
                return A + ' < ' + B
        return A + ' = ' + B
    elif len(a) > len(b):
        for x in range(0,len(b)):
            if int(a[x]) > int(b[x]):
                return A + ' > ' + B
            elif int(a[x]) < int(b[x]):
                return A + ' < ' + B
        return A + ' > ' + B
    elif len(a) < len(b):
        for x in range(0,len(a)):
            if int(a[x]) > int(b[x]):
                return A + ' > ' + B
            elif int(a[x]) < int(b[x]):
                return A + ' < ' + B
        return A + ' < ' + B

print compare_version('0.0.2', '0.0.1')
print compare_version('1.0.10', '1.0.3')
print compare_version('1.2.0', '1.1.99')
print compare_version('1.1', '1.0.1')

이렇게 하니까 제대로 나오네요

python 3.0 1주일차.. 조금 난잡하네요;; 버전에 대한 자리수가 달라도 에러가나지 않도록 하였습니다. 입력받는 형태로 구현하였습니다.

while True :
    input_a = input("A 버전을 입력하세요 : ")
    input_b = input("B 버전을 입력하세요 : ")

    list_a = input_a.split('.')
    list_b = input_b.split('.')

    if len(list_a) > len(list_b) : 
        int_len = len(list_a)
        for i in range(len(list_a) - len(list_b)) :
            list_b = list_b + ['0']
    else :  
        int_len = len(list_b)
        for i in range(len(list_b) - len(list_a)) :
            list_a = list_a + ['0']

    for i in range(0,int_len) :
        if int(list_a[i]) > int(list_b[i]) :
            print(input_a + ' > ' + input_b)
            break
        elif int(list_a[i]) < int(list_b[i]) :
            print(input_a + ' < ' + input_b)
            break
        elif (int(list_a[i]) == int(list_b[i])) and (i == int_len-1) :
            print(input_a + ' = ' + input_b)

String[] versionAarr = versionA.split("\."); String[] versionBarr = versionB.split("\.");

    int arrLength = versionAarr.length > versionBarr.length ? versionAarr.length : versionBarr.length;

    int tmpVersionA = 0;
    int tmpVersionB = 0;

    int multi = 1;
    for(int i = arrLength - 1 ; i >= 0; i--){

        if( i <= versionAarr.length-1){
            tmpVersionA += (Integer.parseInt(versionAarr[i]) * multi);
        }

        if(i <= versionBarr.length-1){
            tmpVersionB += (Integer.parseInt(versionBarr[i]) * multi);
        }

        multi *= 1000;
    }


    if(tmpVersionA > tmpVersionB){

        return versionA + ">" + versionB;

    }

    if(tmpVersionA == tmpVersionB){

        return versionA + "=" + versionB;

    }

    if(tmpVersionA < tmpVersionB){

        return versionA + "<" + versionB;

    }

import java.util.Arrays;
import java.util.Scanner;

import static java.lang.System.in;

public class VersionCompare {

    public static void main(String[] args) {
        Scanner sc = new Scanner(in);
        String i = sc.next();
        String ii = sc.next();
        String[] a = i.split("\\.");
        String[] b = ii.split("\\.");

        int len = a.length > b.length ? a.length : b.length;

        String[] aa = Arrays.copyOf(a, len);
        String[] bb = Arrays.copyOf(b, len);

        for (int j = 0; j < len; j++) {
            int k = aa[j] == null ? 0 : Integer.valueOf(aa[j]);
            int l = bb[j] == null ? 0 : Integer.valueOf(bb[j]);

            if (k < l) {
                System.out.println(i + " < " + ii);
                break;
            } else if (k > l) {
                System.out.println(i + " > " + ii);
                break;
            }
        }
    }
}

package codingdojang;

import java.util.Scanner;

public class VersionCompare {
        //말그대로 버전을 비교하는 코드
        //어느 버전이 더 큰지 
        //ex)1.2.1 > 1.0
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner s =new Scanner(System.in);
        String A="";
        System.out.println("두개를 입력");
        String x=s.nextLine();
        String y=s.nextLine();

        String arrX[]=x.split("[.]");
        String arrY[]=y.split("[.]");
        int length=((arrX.length>arrY.length) ? arrX.length : arrY.length);
        for(int i=0;i<length;i++){

            if(Integer.parseInt(arrX[i])>Integer.parseInt(arrY[i])){
                A=x+" > "+y;
                break;
                }else if(Integer.parseInt(arrX[i])<Integer.parseInt(arrY[i])){
                A=x+" < "+y;
                break;

                }

        }

        System.out.println(A);      

    }

}

import java.util.*;

public class version_checker {

    public static void main(String[] args){
        Scanner sc1 = new Scanner(System.in);
        Scanner sc2 = new Scanner(System.in);

        System.out.println("버전 1을 입력하세요=");
        String line1 = sc1.nextLine();  

        System.out.println("버전 2를 입력하세요=");
        String line2 = sc2.nextLine();  

        String [] array_line1 = line1.split("\\."); 
        String [] array_line2 = line2.split("\\."); 

        String ver1 = "";
        String ver2 = "";   
        for(String i:array_line1){ver1 += i;} 
        for(String i:array_line2){ver2 += i;} 

        if(ver1.length() > ver2.length()){for(int i = 0;i<ver1.length()-ver2.length();i++){ver2 += "0";}}       
        else{for(int i = 0;i<ver2.length()-ver1.length();i++){ver1 += "0";}}

        if(Integer.parseInt(ver1)>Integer.parseInt(ver2)){System.out.println(line1+">"+line2);}
        else{System.out.println(line1+"<"+line2);}      
    }
}

def version(v1, v2):
    if v1 == v2: print(v1+ " = " +v2)
    compare = list(zip(v1.split('.'), v2.split('.')))
    for (m,n) in compare:
        if m > n: print(v1+ ' > ' +v2); break
        elif m < n: print(v1+ ' < ' +v2); break

public void go(String version1,String version2) {
        String [] v1 = version1.split("\\.");
        String [] v2 = version2.split("\\.");
        int ver1,ver2;
        int length = Math.min(v1.length, v2.length);


            for(int i =0 ; i<length ; i++) {
                ver1 = Integer.parseInt(v1[i]);
                ver2 = Integer.parseInt(v2[i]);
                if(i==length-1 && ver1==ver2) {

                    if(v1.length>v2.length){
                        System.out.print(version1+" > "+version2); 
                    }else {
                        System.out.print(version2+" > "+version1); 
                    }

                }
                if(ver1>ver2) {
                    System.out.print(version1+" > "+version2); break;
                }else if(ver1<ver2) {
                    System.out.print(version2+" > "+version1); break;
                }

            }
        }

Python 3.5.1

def ver_comp(ver1, ver2): # version 비교 함수
    temp1 = ver1.split('.') # 파라미터 list로 만들고
    temp2 = ver2.split('.')

    if len(temp1) != len(temp2): # length 다르면

        ma = max(len(temp1), len(temp2))
        mi = min(len(temp1), len(temp2))

        if len(temp1) > len(temp2): # 짧은 쪽 '0' 채워 맞추고
            temp2[mi:ma] = '0'*(ma-mi)
        else:
            temp1[mi:ma] = '0'*(ma-mi)

    for x,y in zip(temp1, temp2): # zip 만들고 iter
        if x > y: # 다르면 출력 return
            print (ver1, ">", ver2); return
        elif x < y:
            print (ver1, "<", ver2); return

    print (ver1, "=", ver2); return # 다르지 않으면 출력 return _ 1.0.0 = 1.0


ver1 = input("1번 파일 버전을 입력하세요:") # Str input
ver2 = input("2번 파일 버전을 입력하세요:")

if ver1 == ver2: # 값이 같을 땐 "=" 종결
    print (ver1, "=", ver2)
else:
    ver_comp(ver1, ver2) # 값이 다를 땐 함수 전달 후 비교

def compver(a,b):
    first=[int(i) for i in list(a.split('.'))]
    second=[int(i) for i in list(b.split('.'))]
    if first>second:
        return a+">"+b
    if first<second:
        return a+"<"+b
    else:
        return a+"="+b

print(compver("0.0.2","0.0.1"))
print(compver("1.0.10","1.0.3"))
print(compver("1.2.0","1.1.99"))
print(compver("1.1","1.0.1"))

package training;

public class CompareVersion {

    public static void main(String[] args) {

        //String str1 = "1.2.0";
        //String str2 = "1.1.99";
        String str1 = "1.1";
        String str2 = "1.0.1";      
        //String str1 = "0.0.2";
        //String str2 = "0.0.1";

        String[] arr1 = str1.split("[.]");      
        String[] arr2 = str2.split("[.]");

        int iSize = 0;
        if(arr1.length > arr2.length){
            iSize = arr2.length;
        } else {
            iSize = arr1.length;
        }

        for(int i=0;i<iSize;i++){
            if(Integer.parseInt(arr1[i]) > Integer.parseInt(arr2[i])){
                System.out.println(str1+">"+str2);
                break;
            } else if(Integer.parseInt(arr1[i]) == Integer.parseInt(arr2[i])){
                continue;
            } else {
                System.out.println(str1+"<"+str2);
                break;
            }
        }
    }

}

배열만 사용한 답변 제출합니다.

import java.util.*;

public class ExampleTest {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[] versionFirstNum = new int[4];
        int[] versionSecondNum = new int[4];

        System.out.println("[ 첫번째 프로그램 버전을 입력합니다. ]");
        for(int inputFirstNum = 1; inputFirstNum <= 3; inputFirstNum++) {
            System.out.print("제 " +inputFirstNum +" 버전 숫자값 > ");
            int inputVersion = scanner.nextInt();
            versionFirstNum[inputFirstNum] = inputVersion;
            System.out.println("입력된 버전 값은 " +inputVersion +"입니다.");
            System.out.println("현재 버전 : " +versionFirstNum[1] +"." +versionFirstNum[2] +"." +versionFirstNum[3]);
        }
        System.out.println("[ 두번째 프로그램 버전을 입력합니다. ]");
        for(int inputSecondNum = 1; inputSecondNum <= 3; inputSecondNum++) {
            System.out.print("제 " +inputSecondNum +" 버전 숫자값 > ");
            int inputVersion = scanner.nextInt();
            versionSecondNum[inputSecondNum] = inputVersion;
            System.out.println("입력된 버전 값은 " +inputVersion +"입니다.");
            System.out.println("현재 버전 : " +versionSecondNum[1] +"." +versionSecondNum[2] +"." +versionSecondNum[3]);
        }

        System.out.println();
        System.out.println("[ 두 프로그램의 버전을 비교합니다. ]");
        if(versionFirstNum[1] < versionSecondNum[1]) {
            System.out.println(versionFirstNum[1] +"." +versionFirstNum[2] +"." +versionFirstNum[3] +" < " +versionSecondNum[1] +"." +versionSecondNum[2] +"." +versionSecondNum[3]);
        }
        else if(versionFirstNum[1] > versionSecondNum[1]) {
            System.out.println(versionFirstNum[1] +"." +versionFirstNum[2] +"." +versionFirstNum[3] +" > " +versionSecondNum[1] +"." +versionSecondNum[2] +"." +versionSecondNum[3]);
        } else {
            if(versionFirstNum[2] < versionSecondNum[2]) {
                System.out.println(versionFirstNum[1] +"." +versionFirstNum[2] +"." +versionFirstNum[3] +" < " +versionSecondNum[1] +"." +versionSecondNum[2] +"." +versionSecondNum[3]);
            }
            else if(versionFirstNum[2] > versionSecondNum[2]) {
                System.out.println(versionFirstNum[1] +"." +versionFirstNum[2] +"." +versionFirstNum[3] +" > " +versionSecondNum[1] +"." +versionSecondNum[2] +"." +versionSecondNum[3]);
            } else {
                if(versionFirstNum[3] < versionSecondNum[3]) {
                    System.out.println(versionFirstNum[1] +"." +versionFirstNum[2] +"." +versionFirstNum[3] +" < " +versionSecondNum[1] +"." +versionSecondNum[2] +"." +versionSecondNum[3]);
                }
                else if(versionFirstNum[3] > versionSecondNum[3]) {
                    System.out.println(versionFirstNum[1] +"." +versionFirstNum[2] +"." +versionFirstNum[3] +" > " +versionSecondNum[1] +"." +versionSecondNum[2] +"." +versionSecondNum[3]);
                } else {
                    System.out.println(versionFirstNum[1] +"." +versionFirstNum[2] +"." +versionFirstNum[3] +" = " +versionSecondNum[1] +"." +versionSecondNum[2] +"." +versionSecondNum[3]);
                }
            }
        }
        System.out.println();
        System.out.println("[ 결과 계산 완료 ]");
    }
}

Python 3.4.2 각 버전을 입력받아 비교

import itertools

def latest_ver(m,n):
    if m == n:
        return print("Same version.")
    else:
        m_int = map(int, m.split('.'))
        n_int = map(int, n.split('.'))
        for a,b in itertools.zip_longest(m_int, n_int):
            if a > b:
                return print("Version 1 is latest version")
            elif a < b:
                return print("Version 2 is latest version")


ver1 = input("Enter version 1: ")
ver2 = input("Enter version 2: ")

latest_ver(ver1, ver2)

v1 = '1.0.2'
v2 = '0.1.1'

v1_stock = []
v2_stock = []

for i in v1.split('.'):
    v1_stock.append(i)

for j in v2.split('.'):
    v2_stock.append(j)


k = 0
running = True
while(running):
    if v1_stock[k]>v2_stock[k]:
        print(v1+ " > " +v2)
        running = False
    elif v1_stock[k] < v2_stock[k]:
        print(v1+ " < " +v2)
        running = False

    k=k+1

a = input("input first version : ")
b = input("input second version : ")

c = [int(i) for i in a.split(".")]
d = [int(j) for j in b.split(".")]

g = abs(len(c) - len(d))

if len(c) > len(d):
    [d.append(0) for i in range(g)]

elif len(c) < len(d):
    [c.append(0) for i in range(g)]


for i in range(0,len(c)):
    if c[i] > d[i]:
        print ("%s > %s" %(a,b))
        break
    elif c[i] < d[i]:
        print ("%s < %s" %(a,b))
        break
    elif c == d:
        print ("same version")
        break

javascript

var parseVer = ver => ver.split(".").map(v => parseInt(v));

var compVer = function (v1, v2) {
    var equality = "=";
    var [s1, s2] = [parseVer(v1), parseVer(v2)];
    var len = Math.max(s1.length, s2.length);

    for (let i = 0; i < len; i++) {
        var [x1, x2] = [s1[i] || 0, s2[i] || 0];

        if (x1 > x2) {
            equality = ">";
            break;
        } else if (x1 < x2) {
            equality = "<";
            break;
        }
    }

    return `${v1} ${equality} ${v2}`;
};

var assertEqual = (a, b) => console.log(a === b);

assertEqual(compVer("0.0.2", "0.0.1"),  "0.0.2 > 0.0.1");
assertEqual(compVer("0.1.2", "3.0.1"),  "0.1.2 < 3.0.1");
assertEqual(compVer("1.0.0", "1.0"),    "1.0.0 = 1.0");
assertEqual(compVer("1.2.0", "1.1.99"), "1.2.0 > 1.1.99");
assertEqual(compVer("1.1", "1.0.1"),    "1.1 > 1.0.1");
assertEqual(compVer("3.01", "3.1"),     "3.01 = 3.1");

C#

오류 처리는 안 했습니다.

using static System.Console;

class VersionComparison
{
    static void Main(string[] args)
    {
        string v1 = "0.0.2", v2 = "0.0.1";
        //string v1 = "1.0.10", v2 = "1.0.3";
        //string v1 = "1.2.0", v2 = "1.1.99";
        //string v1 = "1.1", v2 = "1.0.1";

        string[] V1 = v1.Split('.');
        string[] V2 = v2.Split('.');
        int len = V1.Length >= V2.Length ? V1.Length : V2.Length;

        for (int i = 0; i < len; i++)
        {
            int s1 = i < V1.Length ? int.Parse(V1[i]) : 0;
            int s2 = i < V2.Length ? int.Parse(V2[i]) : 0;
            if (s1 != s2)
            {
                if (s1 > s2)
                {
                    WriteLine(v1 + " > " + v2);
                }
                else
                {
                    WriteLine(v2 + " > " + v1);
                }
                break;
            }
        }
    }
}

파이선

a="1.1"
b="1.0.1.1"
ver1=a.replace (".","")
ver2=b.replace (".","")

if len(a) > len(b) :
   ver2=ver2+("0"*(len(ver1)-len(ver2)))
if len(a) < len(b) :
   ver1=ver1+("0"*(len(ver2)-len(ver1)))

if (ver1>ver2):
    print(ver1+">"+ver2)
if (ver2>ver1):
    print(ver1+"<"+ver2)

1100>1011

def checkVersions(ver1, ver2):
    ver1 = list(map(int, ver1.split('.')))
    ver2 = list(map(int, ver2.split('.')))
    max_len = max([len(ver1), len(ver2)])
    ver1 = ver1 + [0] * (max_len - len(ver1))
    ver2 = ver2 + [0] * (max_len - len(ver2))

    for i1 in range(0, max_len):
        if ver1[i1] > ver2[i1]:
            print(ver1, '>', ver2)
            return
        elif ver1[i1] < ver2[i1]:
            print(ver1, '<', ver2)
            return
    print(ver1, '=', ver2)

checkVersions('0.0.2','0.0.2')
checkVersions('0.0.2','0.0.1')
checkVersions('1.0.10','1.0.3')
checkVersions('1.2.0','1.1.99')
checkVersions('1.1','1.0.1')
checkVersions('1.1','1.1.1')

JAVA

    public static void main(String[] args) {
        String ver1 = "1.1", ver2 ="1.0.1";
        String[] dep1 = ver1.split("\\.");
        String[] dep2 = ver2.split("\\.");

        for(int i = 0; i < 3; i++) {
            if(Integer.parseInt(dep1[i]) > Integer.parseInt(dep2[i])) {
                System.out.println(ver1 + " > " + ver2);
                return;
            } else if(Integer.parseInt((dep1[i])) < Integer.parseInt((dep2[i]))) {
                System.out.println(ver1 + " < " + ver2);
            }
        }
    }

Integer 없이 구현해봤습니다. 가급적이면 오류를 최소화하려고 각 Place에 있는 버전들을 직접 int 단위로 비교하는 코드입니다. 코멘트 감사히 받겠습니다.

import java.util.Arrays;

public class DiffrenceInVersion {
    static int[] version_1 = new int[3]; static int[] version_2 = new int[3];

    public static void LoadVersion(int versionPlace) {
        switch(versionPlace) {
        case 1:
            System.out.print(version_1[0] +"." +version_1[1] +"." +version_1[2]); break;

        case 2:
            System.out.print(version_2[0] +"." +version_2[1] +"." +version_2[2]); break;
        }
    }

    public static void main(String[] args) {
        boolean calculating = true; int versionPlace = 0;
        version_1[0] = 1; version_1[1] = 0; version_1[2] = 10;
        version_2[0] = 1; version_2[1] = 0; version_2[2] = 3;

        while(calculating) {
            if(version_1[versionPlace] > version_2[versionPlace]) {
                LoadVersion(1); System.out.print(" > "); LoadVersion(2); calculating = false;
            } else if(version_1[versionPlace] < version_2[versionPlace]) {
                LoadVersion(1); System.out.print(" < "); LoadVersion(2); calculating = false;
            } else {
                versionPlace++;
                if(versionPlace == 3) {
                    LoadVersion(1); System.out.print(" = "); LoadVersion(2); calculating = false;
                }
            }
        }
    }
}

def compare(v1,v2):
    conv1=v1.split('.')
    conv2=v2.split('.')

    if int(conv1[0])>int(conv2[0]):print(v1,'>',v2)
    elif int(conv1[0])<int(conv2[0]):print(v1,'<',v2)
    elif int(conv1[0])==int(conv2[0]):
        if int(conv1[1])>int(conv2[1]):print(v1,'>',v2)
        elif int(conv1[1])<int(conv2[1]):print(v1,'<',v2)
    if int(conv1[0])==int(conv2[0]) and int(conv1[1])==int(conv2[1]):
        if int(conv1[2])>int(conv2[2]):print(v1,'>',v2)
        elif int(conv1[2])<int(conv2[2]):print(v1,'<',v2)

def cmpVer(str1, str2):
    ver1 = str1.split('.')
    ver2 = str2.split('.')
    if str1 == str2:
        return str1 + ' = ' + str2
    else:
        for i in range(0, min(len(ver1), len(ver2))):
            if ver1[i] > ver2[i]:
                return str1 + ' > ' + str2
            elif ver1[i] < ver2[i]:
                return str1 + ' < ' + str2
        if len(ver1) < len(ver2):
            return str1 + ' < ' + str2
        else:
            return str1 + ' > ' + str2


print(cmpVer('1.1.1', '1.0.1'))
print(cmpVer('1.1.1', '1.1.1'))
print(cmpVer('1.1', '1.1.1'))
print(cmpVer('1.1', '1.1.0'))

python 2.7 입니다

def version_comp (v1, v2):
    v1_lst = v1.split(".")
    v2_lst = v2.split(".")

    vsn_len_diff = (len(v1_lst) - len (v2_lst))   # 버전 회차를 비교하여 짧은 것을 0으로 대체하여 비교가 가능하게 합니다.

    if vsn_len_diff <> 0:
        for i in range(abs(vsn_len_diff)):
            if vsn_len_diff > 0:
                v2_lst.append ('0')
            else:
                v1_lst.append ('0')

    newer = "check"

    for i in range(len(v1_lst)):
        if int(v1_lst[i]) == int(v2_lst[i]):
            newer = "check"
        elif v1_lst[i] > v2_lst[i]:
            newer = v1 + " is newer"
        elif v1_lst[i] < v2_lst[i]:
            newer = v2 + " is newer"

        if newer <> "check":
            break

    return newer

print (version_comp('1.2', '1.2.3'))
print (version_comp('1.0.8.9', '1.1'))

python

verL = ['0.0.2', '0.0.1', '1.0.10', '1.0.3', '1.2.0', '1.1.99', '1.1', '1.0.1']


for i in range(len(verL)):             #버전을 리스트화 시킨다.
    verL[i] = verL[i].split('.') 

def compare(v1, v2, b = '0'):          #길이가 다른 경우 길이를 맞추고 크기를 비교한다.
    m = max(len(v1), len(v2))
    v1.extend([b for i in range(m-len(v1))])
    v2.extend([b for h in range(m-len(v2))])
    for k in range(m):
        if int(v1[k]) > int(v2[k]):
            return str(".".join(v1) + ' > ' + ".".join(v2))
        elif int(v1[k]) < int(v2[k]):
            return str(".".join(v1) + ' < ' + ".".join(v2))

print(compare(verL[2], verL[3]))

python

verL = ['0.0.2', '0.0.1', '1.0.10', '1.0.3', '1.2.0', '1.1.99', '1.1', '1.0.1', '1.1.0']


for i in range(len(verL)):
    verL[i] = verL[i].split('.') 

def compare(v1, v2, b = '0'):
    m = max(len(v1), len(v2))
    l1, l2 = m-len(v1), m-len(v2)
    v1.extend([b for i in range(l1)])
    v2.extend([b for h in range(l2)])
    if v1 == v2:
        for m in range(l1): v1.pop()
        for m in range(l2): v2.pop()
        return str(".".join(v1) + ' = ' + ".".join(v2))
    for k in range(m):
        if int(v1[k]) > int(v2[k]):
            return str(".".join(v1) + ' > ' + ".".join(v2))
        elif int(v1[k]) < int(v2[k]):
            return str(".".join(v1) + ' < ' + ".".join(v2))

print(compare(verL[6], verL[8]))

python입니다 버전의 길이가 다를경우 작은쪽에 0을 삽입해서 비교했습니다

input_version1 = input("첫번째 버전 : ")
input_version2 = input("두번째 버전 : ")
change_input1 = str(input_version1).split(".")
change_input2 = str(input_version2).split(".")

if len(change_input1) > len(change_input2):
    change_input2 = change_input2 + ["0"]*(len(change_input1)-len(change_input2))
elif len(chang_input1) < len(change_input2):
    change_input1 = change_input1 + ["0"]*(len(change_input2)-len(change_input1))

for x in range(len(change_input1)):
    if change_input1[x] > change_input2[x]:
        print(input_version1, ">", input_version2)
        break
    elif change_input1[x] < change_input2[x]:
        print(input_version1, "<", input_version2)
        break
    elif x == len(change_input1[-1]) and change_input1[-1] == change_input2[-1]:
        print(input_version1, "=", input_version2)

def who(vers):
    [x, y]=vers
    x=list(map(int, x.split('.')))
    x_chr='.'.join(map(str, x))
    y=list(map(int, y.split('.')))
    y_chr='.'.join(map(str, y))
    for i in range(min(len(x), len(y))):
        if x[i]>y[i]:
            return(x_chr+' > '+y_chr)
        if x[i]<y[i]:
            return(x_chr+' < '+y_chr)
    else:
        if len(x)==len(y):
            return(x_chr+' = '+y_chr)
        elif len(x)>len(y):
            return(x_chr+' > '+y_chr)
        else :
            return(x_chr+' < '+y_chr)

ver=[]
while len(ver)!=2:
    ver=input('versions(2개): ').split()

print(who(ver))

파이썬 3.6

ver = [ '1.0.3' , '1.1.29' ]

""" 
각 버전 문자열의 동일 인덱스 요소끼리 비교하여 같지 않을 때 요소값이 큰 버전 문자열을 왼쪽에 두고 결과 출력하고
동일할 경우 해당 메세지 출력
"""

def comparever(ver):
    lenlist = []
    lenlist.append(len(list(ver[0])))
    lenlist.append(len(list(ver[1])))
    stringlen = max(lenlist)
    for i in range(stringlen):
        if ver[0][i] > ver[1][i]:
            print(ver[0], '>' ,ver[1], "\n")
            break
        elif ver[0][i] < ver[1][i]:
            print(ver[1], '>', ver[0], "\n")
            break
        else:
            pass
    print( "두 버전은 동일한 버전입니다", "\n")

comparever(ver)

• 겱과값

1.1.29 > 1.0.3

def verchk(ver1,ver2):
    x,y = ver1.split("."), ver2.split(".")
    if  ver1 == ver2 : 
        print("{0} = {1}".format(ver1,ver2))
        return True
    if int(x[0]+x[1])>int(y[0]+y[1]) : print("{0} > {1}".format(ver1,ver2))
    elif int(x[0]+x[1])==int(y[0]+y[1]) :
        if len(x)<=2 and len(y)<=2 : 
            print("{0} = {1}".format(ver1,ver2))
            return True
        elif len(x)>2 and len(y)<=2 :                   
            try :
                if x[2]>y[2] : print("{0} > {1}".format(ver1,ver2))
                else : print("{0} < {1}".format(ver1,ver2))
            except IndexError :
                print("{0} > {1}".format(ver1,ver2))
        else : print("{0} < {1}".format(ver1,ver2))            

    else : print("{0} < {1}".format(ver1,ver2))


verchk("1.2.2","1.1.99")

        //버전 두개
        String aVer = "1.2.10";
        String bVer = "1.1.99";

        String[] aVerArr = aVer.split("\\.");
        String[] bVerArr = bVer.split("\\.");

        for(int i=0; i<aVerArr.length; i++)
        {
            if(Integer.parseInt(aVerArr[i]) != Integer.parseInt(bVerArr[i]) )
            {
                if(Integer.parseInt(aVerArr[i]) > Integer.parseInt(bVerArr[i]) )
                {
                    System.out.println("앞버전이 큼");
                    break;
                }
                else
                {
                    System.out.println("뒷버전이 큼");
                    break;
                }
            }
        }

s1 = input("첫번째 버전을 입력하세요 :")
s2 = input("두번째 버전을 입력하세요 :")
version1 = s1.split('.')
version2 = s2.split('.')
compare = list(zip(version1, version2))
i = 0
while i <= len(compare):
    if int(compare[i][0]) - int(compare[i][1]) > 0:
        print("첫번째 버전이 최신입니다.")
        break
    elif int(compare[i][0]) - int(compare[i][1]) == 0:
        i += 1
    else:
        print("두번째 버전이 최신입니다.")
        break

비효율의 끝을 달리는 코드네요.. 부끄럽지만 반면교사 삼으시라고 올립니다.

s1 = input("첫번째 버전을 입력하세요:").replace('.','')
s2 = input("두번째 버전을 입력하세요:").replace('.','')
if int(s1) - int(s2) > 0:
    print("첫번째 버전이 최신 버전입니다.")
elif int(s1) - int(s2) == 0:
    print("버전이 같습니다.")
else:
    print("두번째 버전이 최신 버전입니다.")

요렇게도 가능하겠네요..

자바로 작성해 보았습니다.

public static void main(String[] args) {
        String v1, v2;
        Scanner cin = new Scanner(System.in);
        int length = 0;
        int result = 0;

        System.out.print("Version_01 = ");
        v1 = cin.nextLine();
        System.out.print("Version_02 = ");
        v2 = cin.nextLine();
        String[] strv_01 = v1.split("\\.");
        String[] strv_02 = v2.split("\\.");
        int[] intv_01 = new int[strv_01.length];
        int[] intv_02 = new int[strv_02.length];
        length = Math.min(intv_01.length, intv_02.length);

        for(int i = 0; i < intv_01.length; ++i) {
            intv_01[i] = Integer.parseInt(strv_01[i]);
        }
        for(int i = 0; i < intv_02.length; ++i) {
            intv_02[i] = Integer.parseInt(strv_02[i]);
        }
        for(int i = 0; i < length; ++i) {
            if(intv_01[i] > intv_02[i]) {
                result = -1;
                break;
            }else if(intv_01[i] < intv_02[i]) {
                result = 1;
                break;
            }else if(i == length){
                if(intv_01.length > length) {
                    result = -1;
                    break;
                }else if(intv_02.length > length){
                    result = 1;
                    break;
                }
            }else {
                result = 0;
                continue;
            }
        }
        switch(result) {
        case -1:
            for(int i = 0; i <= intv_01.length-2; ++i) {
                System.out.print(intv_01[i] + ".");
            }
            System.out.print(intv_01[length-1] + "버전이 더 높습니다.");
            System.out.println();
            break;
        case 0:
            System.out.println("두 버전이 같습니다.");
            break;
        case 1:
            for(int i = 0; i <= intv_02.length-2; ++i) {
                System.out.print(intv_02[i] + ".");
            }
            System.out.print(intv_02[length-1] + "버전이 더 높습니다.");
            System.out.println();
            break;
        }

        cin.close();
    }

v1 = input("버전을 입력하십시오:")
v2 = input("버전을 입력하십시오.")
def vercon(ver1, ver2):
    s1 = ver1
    s2 = ver2
    l1 = list(s1.split('.'))
    while(len(l1)<3):
        l1.append('0')
    l2 = list(s2.split('.'))
    while(len(l2)<3):
        l2.append('0')
    x = int(max(max(l1), max(l2)))+1
    x1 = int(l1[0])*x*x+int(l1[1])*x+int(l1[2])
    x2 = int(l2[0])*x*x+int(l2[1])*x+int(l2[2])
    if x1 > x2:
        return "{0} > {1}".format(s1, s2)
    elif x1 == x2:
        return "{0} = {1}".format(s1, s2)
    else:
        return "{0} < {1}".format(s1, s2)

print(vercon(v1, v2))

while True:
    print('이 프로그램은 버전을 차례로 입력하면 어느 버전이 더 큰 지 알려줍니다.\n마지막 자리가 0일 경우 입력하지 마세요. ex.1.3.0일 경우 1.3으로 입력')
    a=input('버전을 입력하세요:').split('.')
    b=input('버전을 입력하세요:').split('.')
    i=0
    m=min(len(a),len(b))
    while i<m:
        if a[i]>b[i]:
            print('먼저 입력한 버전이 더 큽니다.')
            break
        if a[i]<b[i]:
            print('먼저 입력한 버전이 더 작습니다.')
            break
        i+=1
    if i==m:
        if len(a)==len(b):print('두 버전은 같습니다.')
        elif len(a)>len(b):print('먼저 입력한 버전이 더 큽니다.')
        else:print('먼저 입력한 버전이 더 작습니다.')

def version_comparing():
    a=raw_input('version a:')
    b=raw_input('version b:')

    aa=a.split('.')
    bb=b.split('.')

    aa=[int(x) for x in aa]
    bb=[int(x) for x in bb]

    for i in range(len(aa)):

        if aa[i]>bb[i]:
            print a,'>',b
            break
        elif aa[i]<bb[i]:
            print a,'<',b
            break

version_a=input('버전을 입력하세요\n')
version_b=input('버전을 입력하세요\n')


version_a_list=version_a.split('.')                
version_b_list=version_b.split('.')

ver_a_str=''
for k in version_a_list:
    ver_a_str+=k

ver_b_str=''
for g in version_b_list:
    ver_b_str+=g

if len(ver_a_str)>len(ver_b_str):
    ver_b_str+='0'*(len(ver_a_str)-len(ver_b_str))

if len(ver_b_str)>len(ver_a_str):
    ver_a_str+='0'*(len(ver_b_str)-len(ver_a_str))

if int(ver_b_str)>int(ver_a_str):
    print(version_b+'>'+version_a)

if int(ver_a_str)>int(ver_b_str):
    print(version_a+'>'+version_b)

if int(ver_b_str)==int(ver_a_str):
    print(version_b+'='+version_a)

버전을 숫자로 바꿔서 비교했습니다

public class versionCompare {

    private String[] version1;
    private String[] version2;
    private int size;
    private int returnValue;

    public versionCompare(String version1, String version2) {
        this.version1 = version1.split("\\.");
        this.version2 = version2.split("\\.");
        if(this.version1.length >= this.version2.length) {
            size = this.version1.length;
        }else {
            size = this.version2.length;
        }
    }

    public int compareVersion() {
        for(int i = 0; i < size; i++) {
            int number1 = 0;
            int number2 = 0;
            try {
                number1 = Integer.parseInt(version1[i]);
            } catch(Exception e) {
                //e.printStackTrace();
                number1 = 0;
            }
            try {
                number2 = Integer.parseInt(version2[i]);
            } catch(Exception e) {
                //e.printStackTrace();
                number2 = 0;
            }
            if(number1 > number2) {
                return 1;
            } else if(number2 > number1) {
                return -1;
            } else {
                returnValue = 0;
            }
        }
        return returnValue;
    }
}

자바입니다!

package CodingDojang;

import java.util.*;

public class VersionComparing {

    private static String versionCompare(String version1, String version2) {
        String[] v1Seperated = version1.split("\\.");
        String[] v2Seperated = version2.split("\\.");
        int i = 0;
        String latestVersion = null;

        while(latestVersion == null) {
            try {
                if(Integer.parseInt(v1Seperated[i]) > Integer.parseInt(v2Seperated[i])) {
                    latestVersion = version1;
                } else if(Integer.parseInt(v1Seperated[i]) < Integer.parseInt(v2Seperated[i])) {
                    latestVersion = version2;
                }
            } catch (Exception e) {
                if(v1Seperated.length > v2Seperated.length) {
                    latestVersion = version1;
                } else if(v1Seperated.length < v2Seperated.length) {
                    latestVersion = version2;
                } else {
                    latestVersion = "same";
                }
            }
            i++;
        }

        return latestVersion;
    }

    public static void main(String args[]) {
        Scanner scn = new Scanner(System.in);
        String originVersion, targetVersion;

        originVersion = scn.next();
        targetVersion = scn.next();

        System.out.println(versionCompare(originVersion, targetVersion));

        scn.close();
    }
}

def compare(a, b):
    varsion_a = a.split('.')
    varsion_b = b.split('.')
    if len(varsion_a) > len(varsion_b):
        while len(varsion_a) > len(varsion_b):
            varsion_b.append('0')
    elif len(varsion_a) < len(varsion_b):
        while len(varsion_a) < len(varsion_b):
            varsion_a.append('0')
    for n in range(len(varsion_a)):
        if varsion_a[n] > varsion_b[n]:
            result = '>'
            break
        elif varsion_a[n] < varsion_b[n]:
            result = '<'
            break
        elif n + 1 == len(varsion_a):
            result = '='
    return a + ' ' + result + ' ' + b

Python 3입니다. 단순하게 문자열을 잘라서 하나하나 비교하는 방법을 사용했습니다.

Swift입니다. 입력된 버젼을 숫자로 바꾸어서 비교를 합니다. 버젼은 포맷에 맞게 입력되었다고 가정하며, 10자리 버젼까지 동작하도록 되어 있습니다.

import Foundation

func getVersion(_ ver: String) -> Int {
    let verSArray = ver.split(separator:".")
    let adjustVersion = 10 - verSArray.count
    let verIArray = verSArray.map({Int($0) ?? 0})
    return verIArray.reduce(0, {return $0 * 10 + $1}) * Int(pow(Double(10), Double(adjustVersion)))
}

print("Enter first version: ", terminator: " ")
if let ver1 = readLine() {
    print("Enter second version: ", terminator: " ")
    if let ver2 = readLine() {
        let verInt1 = getVersion(ver1)
        let verInt2 = getVersion(ver2)

        print("\(ver1) \((verInt1 > verInt2) ? ">" : ((verInt1 < verInt2) ? "<" : "=")) \(ver2)")
    }
}

def compare(a, b):
    if a>b:
        return 1
    elif a==b:
        return 0
    else :
        return -1


inp1 = input()
inp2 = input()

tmp1 = inp1.split(".")
tmp2 = inp2.split(".")

flag = 0

for i in range(len(tmp1)):
    if compare(tmp1[i],tmp2[i]) == 1:
        res = ">"
        break
    elif compare(tmp1[i],tmp2[i]) == -1:
        res = "<"
        break
    else:
        res = "="

print(".".join(tmp1)+" "+res+" "+".".join(tmp2))

def version(a,b) :
    a_list = a.split('.')
    b_list = b.split('.')
    for  i in zip(a_list,b_list):
        if i[0] > i[1] : return "{0} > {1}".format(a,b)
        elif i[0] < i[1] : return "{0} < {1}".format(a,b)
        else : continue
    else : return "{0} = {1}".format(a,b)


print(version("6.7","1.0.4"))
print(version("1.0.2","1.0.4"))
print(version("1.0","1.0"))
print(version("1.0","1"))

재귀함수를 이용해서 (1.0, 1.0.0.1) , (1.1.1.4.5 , 1.1.1) 같은 경우도 비교할 수 있게끔 일반화 해봤습니다.

# 두개의 버전값을 입력받아(ex 1.2.0.1 과 1.2.3) 크기를 비교하여 출력
def version_comparison():
    def ver_comp(a, b, i):
        global a_ini, b_ini
        if i == 0:
            a_ini, b_ini = ".".join(map(str, a)), ".".join(map(str, b))
        while len(a) < max(len(a), len(b)):
            a += [0]
        while len(b) < max(len(a), len(b)):
            b += [0]
        if len(a) == 0:
            return print('%s = %s' % (a_ini, b_ini))
        elif a[0] > b[0]:
            return print('%s > %s' % (a_ini, b_ini))
        elif a[0] < b[0]:
            return print('%s < %s' % (a_ini, b_ini))
        else:
            i += 1
            ver_comp(a[1:], b[1:], i)
    ver1 = list(map(int, input('첫 번째 버전을 입력해 주세요. : ').split('.')))
    ver2 = list(map(int, input('두번 째 버전을 입력해 주세요. : ').split('.')))
    print(ver_comp(ver1, ver2, 0))


try:
    version_comparison()
except ValueError as v:
    print('잘못 입력하셨습니다.\n오류 :', v)

public static void versionCheck(String v1, String v2){
        String[] vArr1 = v1.split("\\.");
        String[] vArr2 = v2.split("\\.");
        int min=0;
        boolean lengthCk = false;

        if(vArr1.length!=vArr2.length){
            lengthCk = false;
            if(vArr1.length>vArr2.length){
                min = vArr2.length;
            }else{
                min = vArr1.length;
            }
        }else{
            min = vArr1.length;
            lengthCk = true;
        }

        for(int i=0; i<min; i++){
            if(!vArr1[i].equals(vArr2[i])){
                if(Integer.parseInt(vArr1[i])>Integer.parseInt(vArr2[i])){
                    System.out.println(v1+" > "+v2);
                }else{
                    System.out.println(v1+" < "+v2);
                }
                break;
            }else{
                if(i+1==min && !lengthCk){
                    if(vArr1.length>vArr2.length){
                        System.out.println(v1+" > "+v2);
                    }else{
                        System.out.println(v1+" < "+v2);
                    }
                }
            }
        }

    }

아직 많이 모자릅니다 ^^;

a = input('input version ==> ')

args = a.split(" ")
v1_list = args[0].split('.')
v2_list = args[1].split('.')

def com(v1 , v2):
    i = 0
    for v in v1_list:
        if v > v2_list[i]:
            return '.'.join(v1)+' > '+'.'.join(v2)
        elif v < v2_list[i]:
            return '.'.join(v1)+' < '+'.'.join(v2)
        i = i + 1

    return '.'.join(v1)+'='+'.'.join(v2)


print(com(v1_list, v2_list))

python3 입니다

v1 = input("버전을 입력: ")
v2 = input("비교할 버전을 입력: ")

if v1.count('.') > v2.count('.'): #v1과 v2 개수 맞추기
    v2 += '.0' * (v1.count('.') - v2.count('.'))
elif v2.count('.') > v1.count('.'):
    v1 += '.0' * (v2.count('.') - v1.count('.'))
else:
    pass

vl1 = v1.split('.')
vl2 = v2.split('.')

try:
    for i in range(len(v1)):
        if vl1[i] > vl2[i]:
            print(v1 + ' > ' + v2)
            break
        elif vl2[i] > vl1[i]:
            print(v2 + ' > ' + v1)
            break
        else:
            pass
except IndexError:
    print(v2 + ' = ' + v1)

package main

import (
    "fmt"
    "strconv"
    "strings"
)

func v2s(aString string) []int { // version string to slice
    rst := []int{}
    for _, v := range strings.Split(aString, ".") {
        cnv, _ := strconv.Atoi(v)
        rst = append(rst, cnv)
    }
    return rst
}

func equalizeSliceLen(aSlice, bSlice []int) ([]int, []int) { // equalize lens of slices
    minLen, maxLen := len(aSlice), len(bSlice)
    minSlice, maxSlice := aSlice, bSlice
    swapd := false
    if minLen > len(bSlice) {
        minLen, maxLen = maxLen, minLen
        minSlice, maxSlice = maxSlice, minSlice
        swapd = true
    }
    for idx := 0; idx < maxLen-minLen; idx++ {
        minSlice = append(minSlice, 0)
    }
    if swapd {
        return maxSlice, minSlice
    } else {
        return minSlice, maxSlice
    }

}

func intCmp(l, r int) string {
    switch {
    case l > r:
        return ">"
    case l < r:
        return "<"
    default:
        return "="
    }
}

func sliceCmp(lSlice, rSlice []int) string { // return slices compare result
    lSliceNew, rSliceNew := equalizeSliceLen(lSlice, rSlice)
    end := len(lSliceNew)
    for i := 0; i < end; i++ {
        if cmp := intCmp(lSliceNew[i], rSliceNew[i]); cmp != "=" {
            return cmp
        } else {
            continue
        }
    }
    return "="
}

func VersionCompare(lstring, rstring string) string {
    return lstring + " " + sliceCmp(v2s(lstring), v2s(rstring)) + " " + rstring
}

func main() {
    var lver, rver string
    lver, rver = "0.0.2", "0.0.1"
    fmt.Println(VersionCompare(lver, rver))
    lver, rver = "1.0.10", "1.0.3"
    fmt.Println(VersionCompare(lver, rver))
    lver, rver = "1.2.0", "1.1.99"
    fmt.Println(VersionCompare(lver, rver))
    lver, rver = "1.1", "1.0.1"
    fmt.Println(VersionCompare(lver, rver))
}

a = input("첫번쨰 버전을 입력하셈 :")
b = input("두번쨰 버전을 입력하셈 :")
c = a.split(".")
d = b.split(".")
for i in range(10):
    if c[i] != d[i]:
        if int(c[i]) > int(d[i]):
            print("%s > %s" % (a, b))
            break
        else:
            print("%s < %s" % (a, b))
            break

// 자바입니다
public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        for (int i=0; i<n; i++) {
            String[] version1 = br.readLine().split("\\.");
            String[] version2 = br.readLine().split("\\.");
            int stand = 0;
            stand = version1.length>version2.length ? version2.length : version1.length;
            for (int j=0; j<stand; j++) {
                int a = Integer.parseInt(version1[j]);
                int b = Integer.parseInt(version2[j]);
                if (a > b) {
                    System.out.println("version1이 더 큼");
                    break;
                } else if (a < b) {
                    System.out.println("version2가 더 큼");
                    break;
                } else
                    continue;   
            }
        }
    } // "."으로 잘라서 앞에서부터 차례로 비교하는 방법입니다

import java.util.Arrays;
import java.util.Scanner;

import static java.lang.System.in;

public class VersionCompare {

    public static void main(String[] args) {
        Scanner sc = new Scanner(in);
        String i = sc.next();
        String ii = sc.next();
        String[] a = i.split("\\.");
        String[] b = ii.split("\\.");

        int len = a.length > b.length ? a.length : b.length;

        String[] aa = Arrays.copyOf(a, len);
        String[] bb = Arrays.copyOf(b, len);

        for (int j = 0; j < len; j++) {
            int k = aa[j] == null ? 0 : Integer.valueOf(aa[j]);
            int l = bb[j] == null ? 0 : Integer.valueOf(bb[j]);

            if (k < l) {
                System.out.println(i + " < " + ii);
                break;
            } else if (k > l) {
                System.out.println(i + " > " + ii);
                break;
            }
        }
    }
}

정규표현식과 replace를 써봤습니다. 초보라서 코드가 길고 난잡합니다. 노력하겠습니다.

function compareVer(a,b) {
  const redex = /\./gi;

  let compareA = a.replace(redex,"")
  let compareB = b.replace(redex,"")

if(compareA>compareB){
  console.log(`${a} > ${b}`)
} else if(compareA<compareB){
  console.log(`${a} < ${b}`)

}  else if(compareA=compareB){
  console.log(`${a} = ${b}`)

}

}

다른 분들의 코드를 본 받아서 재작성했습니다~~ 너무 잘 작성이 분들이 많네요 ㅎㅎ

from itertools import zip_longest

def version_cmp(left1, right1):
    left2 = map(int, left1.split("."))
    right2 = map(int, right1.split("."))
    for left, right in zip_longest(left2, right2, fillvalue=0):
        if int(left) < int(right):
            return left1 + " < " + right1
        elif int(left) > int(right):
            return left1 + " > " + right1

    else:
        return left1 + " = " + right1

print(version_cmp("0.0.2", "0.0.1"))
print(version_cmp("1.0.10", "1.0.3"))
print(version_cmp("1.2.0", "1.1.99"))
print(version_cmp("1.0.1", "1.1"))
print(version_cmp("1.0.10", "1.0.10"))

ver_1 = input("version 1입력")
ver_2 = input("version 2입력")

version_1 = ver_1.split(".")
version_2 = ver_2.split(".")

def compare(x,y):
    if ((x>y)-(x<y)) == 1:
        print("{}>{}".format(ver_1,ver_2))
    elif ((x>y)-(x<y)) == 0:
        print("{}={}".format(ver_1,ver_2))
    else:
        print("{}<{}".format(ver_1,ver_2))

def main(x,y):
    if len(x) == len(y):
        compare(x,y)
    elif len(x) > len(y):
        y += "0"
        compare(x,y)
    elif len(x) < len(y):
        x += "0"
        compare(x,y)

if __name__ == "__main__":
    main(version_1,version_2)

Python

from itertools import zip_longest
a_test = ["0.0.2", "1.0.10", "1.1.99", "1.0.1", "1.2.0", "1.0", "1.1"]
b_test = ["0.0.1", "1.0.3", "1.2.0", "1.1", "1.2.0", "1.0.0", "1.1.2"]

for a, b in zip(a_test, b_test):
    chk = 0
    for i, j in zip_longest(map(int, a.split(".")), map(int, b.split(".")), fillvalue=0):
        if i > j:
            chk = 1
            break
        elif i < j:
            chk = 2
            break
    if chk == 0:
        print("{} = {}".format(a, b))
    elif chk == 1:
        print("{} > {}".format(a, b))
    else:
        print("{} > {}".format(b, a))

Python 3.6.4

def comp_ver(a, b):
    ver1 = str(a).split('.')
    ver2 = str(b).split('.')
    while len(ver1) > len(ver2):
        ver2 = ver2 + (len(ver1) - len(ver2))*['0']
    while len(ver2) > len(ver1):
        ver1 = ver1 + (len(ver2) - len(ver1))*['0']

    for i in range(3):
        if int(ver1[i]) > int(ver2[i]):
            print("%s > %s" % (a, b))
            break
        elif int(ver2[i]) > int(ver1[i]):
            print("%s < %s" % (a, b))
            break
        else:
            continue

-------------------------------------------------------------------
comp_ver('0.0.2', '0.0.1')
comp_ver('1.0.10', '1.0.3')
comp_ver('1.2.0', '1.1.99')
comp_ver('1.1', '1.0.1')
comp_ver('2', '2.0.1')

-------------------------------------------------------------------
0.0.2 > 0.0.1
1.0.10 > 1.0.3
1.2.0 > 1.1.99
1.1 > 1.0.1
2 < 2.0.1

너무 어렵게 풀었네요

ver1 = input("첫번째 비교할 버전은?")     # ['0', '0', '2']
ver2 = input("두번째 비교할 버전은?")     # ['0', '0', '1']

ver1_temp = ver1.split(".")
ver2_temp = ver2.split(".")

for i in range(max(len(ver1_temp), len(ver2_temp))):
    if int(ver1_temp[i]) > int(ver2_temp[i]):
        print(ver1 + " > " + ver2 )
        break
    elif int(ver1_temp[i]) < int(ver2_temp[i]):
        print(ver1 + " < " + ver2 )
        break
    elif int(ver1_temp[i]) == int(ver2_temp[i]):
        continue

public String compareVer(String ver1, String ver2){ String[] ver1_array = ver1.trim().split("[.]");

    String[] ver2_array =  ver2.trim().split("[.]");

    String result = "";
    int test = Math.min(ver1_array.length , ver2_array.length);
    for(int i = 0 ; i < Math.min(ver1_array.length , ver2_array.length);i++){
        if( Integer.parseInt(ver1_array[i]) > Integer.parseInt(ver2_array[i])){
            result = ver1 + " > " + ver2;
            System.out.println(result);
            return result;

        }
    }
    result = ver1 +" < " + ver2;;
    System.out.println(result);

    return result;


}

def compare_version(input1, input2):
    s_v1 = input1.split('.')
    s_v2 = input2.split('.')

    version1 = list(map(int, s_v1))
    version2 = list(map(int, s_v2))

    len1 = len(version1)    # 버전 1의 길이
    len2 = len(version2)    # 버전 2의 길이

    if len1 != len2:
        min = len1 if len1 < len2 else len2     # len1과 len2중에 더 작은 길이

        if min == len1:     # 버전 1의 길이가 더 작다면
            for i in range(0, min):
                if version1[i] > version2[i]:
                    print("{} > {}".format(input1, input2))
                    return
                elif version1[i] < version2[i]:
                    print("{} < {}".format(input1, input2))
                    return

        else:   # 버전 2의 길이가 더 작다면
            for i in range(0, min):
                if version2[i] > version1[i]:
                    print("{} < {}".format(input1, input2))
                    return
                elif version2[i] < version1[i]:
                    print("{} > {}".format(input1, input2))
                    return

    else:
        for i in range(0, len1):
            if version1[i] > version2[i]:
                print("{} > {}".format(input1, input2))
                return
            elif version1[i] < version2[i]:
                print("{} < {}".format(input1, input2))
                return

    print("{} = {}".format(input1, input2))


input1 = input("version input : ")
input2 = input("version input : ")

compare_version(input1, input2)

def cp(n, m):
    nn = n.split(".")
    mm = m.split(".")
    if int(nn[0]) > int(mm[0]): return print(n)
    elif int(nn[0]) >= int(mm[0]) and int(nn[1]) > int(mm[1]): return print(n)
    elif int(nn[0]) >= int(mm[0]) and int(nn[1]) >= int(mm[1]) and int(nn[2]) > int(mm[2]): return print(n)
    else: return print(m)

cp("1.1", "1.0.1")

v1 = input()
v2 = input()
def ver_comp(ver1, ver2):
    ver1 = ver1.split('.')
    ver2 = ver2.split('.')
    if len(ver1) - len(ver2) < 0: ver1 += [0]*abs(len(ver1)-len(ver2))
    else: ver2 += [0]*abs(len(ver1)-len(ver2))

    for i in range(len(ver1)):
        if int(ver1[i]) > int(ver2[i]): return 1
        elif int(ver1[i]) < int(ver2[i]): return 2
    return 0

x = ver_comp(v1,v2)
print('{} > {}'.format(v1,v2)) if x == 1 else print('{} < {}'.format(v1,v2)) if x == 2 else print('{} = {}'.format(v1,v2))

def version_comparison(versionA,versionB): str_listA = versionA.split('.') int_listA = [int(i) for i in str_listA] str_listB = versionB.split('.') int_listB = [int(i) for i in str_listB]

if int_listA > int_listB:
    return 'A is newer version'
elif int_listA == int_listB:
    return 'Same Version'
else:
    return 'B is newer version'

package com.company;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String st = sc.nextLine();
        String st2 = sc.nextLine();
        int[] ar = split(st);
        int[] ar2 = split(st2);
        Compare(ar, ar2, st, st2);
    }

    public static int[] split(String string)
    {
        String num = string;
        int k = num.split("\\.").length;
        int[] array = new int[k];
        for (int j = 0; j < array.length;j++) 
        {
            array[j]= Integer.parseInt(num.split("\\.")[j]);
        }
        return array;
    }

    public static void Compare(int[] a,int[] b,String st, String st2)
    {
        if (a.length == b.length)
        {
            int i;
            for(i = 0;i<a.length;i++)
            {
                if (a[i] > b[i]) {
                    System.out.println(st + ">" + st2);
                    break;
                }
                else if(a[i]<b[i]) {
                    System.out.println(st + "<" + st2);
                    break;
                }
            }
            if (i == b.length)
                System.out.println(st+"="+st2);

        }
        else if(a.length > b.length)
        {
            int i;
            for(i = 0;i<b.length;i++) 
            {
                if (a[i] > b[i]) 
                {
                    System.out.println(st + ">" + st2);
                    break;
                }
                else if(a[i] < b[i]) 
                {
                    System.out.println(st + "<" + st2);
                    break;
                }
            }
            if (i == b.length)
                System.out.println(st+">"+st2);
        }
        else
        {
            int i;
            for(i = 0;i<a.length;i++) 
            {
                if (a[i] > b[i]) 
                {
                    System.out.println(st + ">" + st2);
                    break;
                }
                else if(a[i] < b[i]) 
                {
                    System.out.println(st + "<" + st2);
                    break;
                }
            }
            if (i == a.length)
                System.out.println(st+"<"+st2);
        }
    }
}

파이썬입니다. "." 없애서 숫자로 만들고 자릿수 맞춰줘서 비교하는 방식입니다.

v1,v2 = input().split()
e = len("".join(v1.split("."))) - len("".join(v2.split(".")))
print(int("".join(v1.split("."))) > int("".join(v2.split("."))) * 10^e)

a1 = '1.1'
a2 = '1.0.1'

a1_array = a1.split('.')
a2_array = a2.split('.')

for i in range(len(a1_array)):
    if int(a1_array[i]) > int(a2_array[i]):
        print(a1 + ' > ' + a2)
        break
    elif int(a1_array[i]) < int(a2_array[i]):
        print(a2 + ' > ' + a1)
        break

package test;

public class test {
    public static void main(String[] args) {
        String[] ver = { "0.0.2", "0.0.1", "1.0.10", "1.0.3", "1.2.0", "1.1.99", "1.1", "1.0.1" };
        for (int i = 0; i < ver.length - 1; i++) {
            String[] a = ver[i].split("\\.");
            for (int j = 1; j < ver.length; j++) {
                String[] b = ver[j].split("\\.");
                if (i != j)
                    end: for (int k = 0; k < 3; k++) {
                        if (Integer.valueOf(a[k]) > Integer.valueOf(b[k])) {
                            System.out.println(ver[i] + " > " + ver[j]);
                            break end;
                        } else if (Integer.valueOf(a[k]) < Integer.valueOf(b[k])) {
                            System.out.println(ver[j] + " > " + ver[i]);
                            break end;
                        }
                        if (k == 1 && (a.length < 3 || b.length < 3)) {
                            if (a.length > b.length) {
                                System.out.println(ver[i] + " > " + ver[j]);
                                break end;
                            } else if (b.length > a.length) {
                                System.out.println(ver[j] + " > " + ver[i]);
                                break end;
                            } else {
                                System.out.println(ver[j] + " = " + ver[i]);
                                break end;
                            }
                        }
                    }
            }
        }
    }
}

v1 = input()
version1 = list(map(int, v1.split('.')))
print(version1)
v2 = input()
version2 = list(map(int, v2.split('.')))
print(version2)

for i in range(min(len(version1), len(version2))):
    if version1[i] > version2[i]:
        print (v1 + '>' + v2)
        break
    elif version1[i] < version2[i]:
        print (v2 + '>' + v1)
        break;
    else:
        continue
else:
    if len(version1) > len(version2):
        print (v1 + '>' + v2)
    elif len(version1) < len(version2):
        print (v2 + '>' + v1)
    else:
        print ('same version')

one = input()
if one.count('.') == 1:
    one += '.0'

two = input()
if two.count('.') == 1:
    two += '.0'

one = one.split('.')
two = two.split('.')

o = int(one[0])
n = int(one[1])
e = int(one[2])

t = int(two[0])
w = int(two[1])
u = int(two[2])

if o > t:
    print('.'.join(one), '>', '.'.join(two))
elif o == t:
    if n > w:
        print('.'.join(one), '>', '.'.join(two))
    elif n == w:
        if e > u:
            print('.'.join(one), '>', '.'.join(two))
        elif e == u:
            print('.'.join(one), '=', '.'.join(two))
        else:
            print('.'.join(one), '<', '.'.join(two))
    else:
        print('.'.join(one), '<', '.'.join(two))
else:
    print('.'.join(one), '<', '.'.join(two))

def __get(target_list, index):
    # index가 존재할경우 해당값을, 없을경우 0을 반환
    try:
        result = target_list[index]
    except:
        result = 0
    finally:
        return int(result)


def compare_ver(a, b):
    A = a.split(".")
    B = b.split(".")

    # 둘중 더 긴 length를 구함.
    max_len = max(len(A), len(B))

    for index in range(0, max_len):
        _a = __get(A, index)
        _b = __get(B, index)

        if _a > _b:
            print("A > B")
            return
        elif _a < _b:
            print("A < B")
            return
        else:
            continue

    print("A == B") 

compare_ver("1.2.3", "1.2.4")
compare_ver("1.2", "1.2.0")
compare_ver("1", "1.2.0")
compare_ver("1.2.3", "1.2.1")

ver_a=str(input("a버젼입력:"))
ver_b=str(input("b버젼입력:"))
def versioncmp(ver_a,ver_b):
    ver_a1=ver_a.split('.')
    ver_b1=ver_b.split('.')
    ver_a1=list(map(int,ver_a1))
    ver_b1=list(map(int,ver_b1))
    for x in range(0,len(ver_a1)):
        if ver_a1[x]>ver_b1[x]:
            print(ver_a+' > '+ver_b)
        elif ver_a1[x]<ver_b1[x]:
            print(ver_a+' < '+ver_b)
versioncmp(ver_a,ver_b)

#include <stdio.h>
#include <stdlib.h>
typedef struct _Version{
    int mainVer;
    int subVer;
    int subVer2;
} Version;
int main()
{
    Version v1,v2;
    printf("input version : ");
    scanf("%d.%d.%d %d.%d.%d",&v1.mainVer,&v1.subVer,&v1.subVer2,&v2.mainVer,&v2.subVer,&v2.subVer2);

    if(v1.mainVer>v2.mainVer){
        printf("%d.%d.%d > %d.%d.%d\n",v1.mainVer,v1.subVer,v1.subVer2,v2.mainVer,v2.subVer,v2.subVer2);
    }else if(v1.mainVer==v2.mainVer){
        if(v1.subVer>v2.subVer){
            printf("%d.%d.%d > %d.%d.%d\n",v1.mainVer,v1.subVer,v1.subVer2,v2.mainVer,v2.subVer,v2.subVer2);
        } else if(v1.subVer==v2.subVer){
            if(v1.subVer2>v2.subVer2){
                printf("%d.%d.%d > %d.%d.%d\n",v1.mainVer,v1.subVer,v1.subVer2,v2.mainVer,v2.subVer,v2.subVer2);
            }else{
                printf("%d.%d.%d < %d.%d.%d\n",v1.mainVer,v1.subVer,v1.subVer2,v2.mainVer,v2.subVer,v2.subVer2);
            }
        }else{
             printf("%d.%d.%d < %d.%d.%d\n",v1.mainVer,v1.subVer,v1.subVer2,v2.mainVer,v2.subVer,v2.subVer2);
        }
    }else{
         printf("%d.%d.%d < %d.%d.%d\n",v1.mainVer,v1.subVer,v1.subVer2,v2.mainVer,v2.subVer,v2.subVer2);
    }
    return 0;
}

#버전 비교 프로그램
def compareVerion(version1,version2):
    mod_ver1 = version1.split('.')
    mod_ver2 = version2.split('.')
    mod1 = "".join(mod_ver1)
    mod2 = "".join(mod_ver2)

    for i in range(0,3):
        if mod1[i] > mod2[i]:
            print("Version 1이 신규 버전 입니다.")
            break
        elif  mod1[i] < mod2[i]:
            print("Version 2가 신규 버전 입니다.")
            break
    if mod1 == mod2:
        print("동일 버전 입니다.")

compareVerion('1.0.1','1.2.3')

tmp = [([0] * 3), ([0] * 3)]

version1 = list(map(int, input("버전 입력 1 : ").split('.')))
version2 = list(map(int, input("버전 입력 2 : ").split('.')))

for i in range(len(version1)) :
    tmp[0][i] = version1[i]
for i in range(len(version2)) :
    tmp[1][i] = version2[i]

print('.'.join(map(str, (sorted(tmp)[-1]))))

a_in = input()
b_in = input()

a_list = list(map(int, a_in.split('.')))
b_list = list(map(int, b_in.split('.')))

for i in range(3):
    if a_list[i] > b_list[i]:
        print("A ver. is higher!")
        break
    elif a_list[i] < b_list[i]:
        print("B ver. is higher!")
        break
    if i == 3: "Both ver. are the same"

namespace codingdojang__
{
    class Program
    {
        static void Main(string[] args)
        {
            string ver1 = Console.ReadLine();
            string ver2 = Console.ReadLine();

            string[] ver1_split = ver1.Split('.');
            string[] ver2_split = ver2.Split('.');

            if (ver1_split.Length > ver2_split.Length)
            {
                for (int i = 0; i < ver1_split.Length; i++)
                {
                    if (int.Parse(ver1_split[i]) > int.Parse(ver2_split[i]))
                    {
                        Console.WriteLine(ver1);
                        break;
                    }
                    else if (int.Parse(ver1_split[i]) < int.Parse(ver2_split[i]))
                    {
                        Console.WriteLine(ver2);
                        break;
                    }
                    else if (int.Parse(ver1_split[i]) == int.Parse(ver2_split[i]))
                    {
                        continue;
                    }
                    else
                    {
                        Console.WriteLine(ver1);
                        break;
                    }
                }
            }
            else if (ver1_split.Length < ver2_split.Length)
            {
                for (int i = 0; i < ver2_split.Length; i++)
                {
                    if (int.Parse(ver1_split[i]) > int.Parse(ver2_split[i]))
                    {
                        Console.WriteLine(ver1);
                        break;
                    }
                    else if (int.Parse(ver1_split[i]) < int.Parse(ver2_split[i]))
                    {
                        Console.WriteLine(ver2);
                        break;
                    }
                    else if (int.Parse(ver1_split[i]) == int.Parse(ver2_split[i]))
                    {
                        continue;
                    }
                    else
                    {
                        Console.WriteLine(ver2);
                        break;
                    }

                }
            }
            else if (ver1_split.Length == ver2_split.Length)
            {
                for (int i = 0; i < ver1_split.Length; i++)
                {
                    if (int.Parse(ver1_split[i]) > int.Parse(ver2_split[i]))
                    {
                        Console.WriteLine(ver1);
                        break;
                    }
                    else if (int.Parse(ver1_split[i]) < int.Parse(ver2_split[i]))
                    {
                        Console.WriteLine(ver2);
                        break;
                    }
                }
            }
        }
    }
}

def comver(v1,v2):

    vc1,vc2 = v1.split('.')+['0']*len(v2),v2.split('.')+['0']*len(v1)

    for x in range(len(v1)):

        if vc1[x] == vc2[x]:
            print('' if x != max(len(v1),len(v2)) else '%s = %s' %(v1,v2), end = '')
            continue

        else:
            print('%s %s %s' %(v1, '>' if int(vc1[x]) > int(vc2[x]) else '<',v2))
            break

def compare(a, b):
    a = list(map(int,a.split('.')))
    b = list(map(int,b.split('.')))
    for i in range(max(len(a),len(b))):
        if a[i] < b[i]:
            return '<'
        elif a[i] > b[i]:
            return '>'
        else:
            continue
a, b = input().split()
print('{0} {1} {2}'.format(a,compare(a,b),b))

version = input("version: ")
version2 = input("version2: ")
#version = '1.0.1'
#version2 = '1.1'
print(version.count('.'))

if version.count('.') > version2.count('.'):
    num = version.count('.') ** 2
else :
    num = version2.count('.') **2

vs = list(map(int,version.split('.')))
vs2 =list(map(int,version2.split('.')))

print(vs)
print(vs2)

vsscore = 0
vsscore2 = 0

for i, j in zip(range(len(vs)), range(len(vs2))) :
    if vs[i] > vs2[j] :
       vsscore += num
       num -= 1 
    elif vs[i] < vs2[j] :
        vsscore2 +=num
        num -= 1

if vsscore > vsscore2 : 
    print(vsscore,'%s가 더 상위버전입니다.'  %version)
elif vsscore == vsscore2:
    print('동일버전')
else : 
    print(vsscore2,'%s가 더 상위버전입니다.'  %version2)

v1 = '1.2.0'
v2 = '1.1.99'

v1_array = v1.split('.')
v2_array = v2.split('.')

for x in range(len(v1_array)):
    if int(v1_array[x]) > int(v2_array[x]):
        print(v1 + ' > ' + v2)
        break
    elif int(v1_array[x]) < int(v2_array[x]):
        print(v2 + ' > ' + v1)
        break

def version(a, b):
    a = a.split('.')
    b = b.split('.')
    length = max(len(a), len(b))
    for i in range(length):
        if a[i] > b[i]:
            print('버전1 > 버전2')
            break
        elif a[i] < b[i]:
            print('버전1 < 버전2')
            break
    return ('버전1 = 버전2')


version (input('버전1 : ') , input('버전2 : '))

def convert_to_num(ver):
    ver1_chunk = ver.split('.')
    ver = 0
    for val in ver1_chunk:
        ver += int(val)
    return ver

print(convert_to_num(ver1) > convert_to_num(ver2))

version1 = input('업데이트를 확인할 프로그램의 버젼을 입력: ')
version2 = input('업데이트할 버젼을 입력: ')

if version1 < version2 :
    print(version1, '<', version2)
    print('성공적으로 업데이트 되었습니다.')
elif version1 == version2 :
    print(version1, '=', version2)
    print('님아, 두 버젼이 똑같음...')
elif version1 > version2 :
    print(version1, '>', version2)
    print('님아, 업데이트가 아닌 다운그레이드를 하실 필요가 없는데...')

Python 3.7 기준으로 작성하였습니다.

def Check_ver(verA,verB):
    a = verA.split('.')
    b = verB.split('.')
    if len(a) > len(b):
        while len(a) != len(b):
            b.append('0')

    elif len(a) < len(b):
        while len(a) != len(b):
            a.append('0')

    ans=''
    for i in range(len(a)):
        if a[i] > b[i]: 
            ans = '>'
            break

        elif a[i] < b[i]:
            ans = '<'
            break

    return ans


verA = '0.1'
verB = '0.1.1'

print(Check_ver(verA,verB))

길이 무식하게 맞춤...

ver1 = input('입력: ').split('.')
ver2 = input('입력: ').split('.')
for index in range(3):
    if int(ver1[index])>int(ver2[index]):
        print('.'.join(ver1),'>','.'.join(ver2))
        break
    elif int(ver1[index])<int(ver2[index]):
        print('.'.join(ver1), '<', '.'.join(ver2))
        break
    elif index==2:
        print('.'.join(ver1), '=', '.'.join(ver2))

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>

#include <string.h>

int main() {

    char *result;                            // 잘린 값 저장

    char ver1[20], ver2[20];        // 버전 입력

    char f1[20], f2[20];                // 원본 저장용

    int temp[20], i = 0, num;     // temp: 첫번째 버전 저장용



    printf("버전 입력: ");

    scanf("%s %s", ver1,ver2);

    strcpy(f1, ver1); strcpy(f2, ver2);     //최종 출력을 위해 저장. strtok를 이용하면 자체에서 계속 잘려 원래 값이 손실된다.



    // 첫번째 입력값 배열에 저장

    result = strtok(ver1, ".");



    while (result != NULL) {

        num = atoi(result); //정수값으로 변환 후 

        temp[i] = num;        // 저장

        result = strtok(NULL, ".");

        i++;

        }



    // 두번째 입력값 첫번째 입력값과 비교

    i = 0;

    result = strtok(ver2, ".");



    while (result != NULL) {

        num = atoi(result);

        if (temp[i] > num) {

            printf("%s > %s\n", f1, f2);    

            break;

        }

        else if (temp[i] < num) {

            printf("%s > %s\n", f2, f1);

            break;

         }

    result = strtok(NULL, ".");

    i++;

    }

    return 0;

}

c로 풀어봤습니다

A = input("ver입력 0.0.0형식")
B = input("ver입력 0.0.0형식")
maxlen = 0
Adot = A.split(".")
Bdot = B.split(".")
#원소 적은걸 기준으로 포문 돌려서 같은 값이면 카운트증가 크면 크고 작으면 작다고
Num = min(len(Adot),len(Bdot))
for i in range(0,Num):
    if Adot == Bdot:
        pass
    if Adot > Bdot:
        print(A, '>', B)
        break
    else:
        print(A, '<', B)
        break

"""
output
ver입력 0.0.0형식0.12.13
ver입력 0.0.0형식0.13.12
0.12.13 < 0.13.12
"""

from itertools import zip_longest

def compVersion(ver1, ver2):
    Version1 = map(int, ver1.split("."))
    Version2 = map(int, ver2.split("."))

    for v1, v2 in zip_longest(Version1, Version2, fillvalue= 0):
        if v1 > v2:
            print(ver1, '>', ver2)
            break
        elif v1 < v2:
            print(ver1, '<', ver2)
            break

compVersion('0.0.2', '0.0.1')
compVersion('1.0.10', '1.0.3')
compVersion('1.2.0', '1.1.99')
compVersion('1.1', '1.0.1')

aa ='1.2.3'
bb ='1.2'

a =aa.split('.')
b= bb.split('.')

if a == b : print(aa, "=" ,bb)        #  같으면 같다고 표시 

[b.append('0') for i in range(len(a)-len(b)) if len(a)>len(b)]  #  1.2 vs 1.2.3 비교위해 작은버전에 0 더하기
[a.append('0') for i in range(len(b)-len(a)) if len(a)<len(b)]        


for i in range(max(len(a), len(b))):   #비교
    if int(a[i]) > int(b[i]): print(aa, ">" ,bb); break   
    elif int(a[i]) < int(b[i]): print(aa, "<" ,bb); break

파이썬으로 무식하게 앞부분부터 비교했습니다.

a = input("버전1: ")
b = input("버전2: ")

a = a.split(".")
b = b.split(".")

if int(a[0]) == int(b[0]) and int(a[1]) == int(b[1]):
    if int(a[2]) == int(b[2]):
        print("버전이 동일합니다.")
    elif int(a[2]) > int(b[2]):
        print("버전 1이 상위버전입니다.")
    else: 
        print("버전 2가 상위버전입니다.")
elif int(a[0]) == int(b[0]):
    if int(a[1]) > int(b[1]):
        print("버전 1이 상위버전입니다.")
    else:
        print("버전 2가 상위버전입니다.")
else:
    if int(a[0]) > int(b[0]):
        print("버전 1이 상위버전입니다.")
    else:
        print("버전 2가 상위버전입니다.")

Ver1,Ver2= map(str,input().split())

Ver11=Ver1.split('.');Ver22=Ver2.split('.')

for i in range(len(Ver1)):
    if Ver1==Ver2:
        print(Ver1 + ' = ' + Ver2)
        break

    elif int(Ver11[i])>int(Ver22[i]):
        print(Ver1 +' > '+Ver2)
        break

    elif int(Ver11[i])< int(Ver22[i]):
        print(Ver1 +' < '+Ver2)
        break

def cmp(L1, L2, idx=0):
    if L1[idx] == L2[idx]:
        return cmp(L1, L2, idx+1)
    else:
        if L1[idx] > L2[idx]: return '>'
        else: return '<'


s1, s2 = input().split()
L1 = list(map(int, s1.split('.')))
L2 = list(map(int, s2.split('.')))
print(s1, cmp(L1, L2), s2)

python3.6

1.1.1 > 1.1 과 같은 케이스도 처리할 수 있도록 짜보았습니다.

def Version_Comparison(list1, list2):
    if list1 == list2:
        print(A, '=', B)
    else:
        for i in range(min(len(list1), len(list2))):
            if int(list1[i]) - int(list2[i]) > 0:
                print(A, '>', B)
                break
            elif int(list1[i]) - int(list2[i]) < 0:
                print(A, '<', B)
                break
            else:
                pass


A, B = input('enter two versions: ').split(' ')
A_list, B_list = A.split('.'), B.split('.')

if len(A_list) == len(B_list):
    Version_Comparison(A_list, B_list)
else:
    A_list += ['0' for i in range(len(B_list)-len(A_list))]
    B_list += ['0' for i in range(len(A_list)-len(B_list))]
    Version_Comparison(A_list, B_list)

파이썬 3.7.2

ver1 = input("비교할 버전 첫번째를 입력하세요\n> ")
ver2 = input("비교할 버전 두번째를 입력하세요\n> ")

ver1_list = ver1.split(".")
ver2_list = ver2.split(".")

for x in range(len(ver1_list)):
    if ver1_list[x] > ver2_list[x]:
        print(ver1+" > "+ver2)
        pass
    if ver1_list[x] < ver2_list[x]:
        print(ver1+" < "+ver2)
        pass

wj k 님 답변 이용했습니다.

def bigger (v1, v2): list1 = list(map(int, v1.split(".")))
list2 = list(map(int, v2.split(".")))

for i in range(min(len(list1), len(list2))):
    if list1[i] > list2[i]:
        return v1
    elif list1[i]  == list2[i] :
        continue
    else:
        return v2

print(bigger("0.0.2", "0.0.1"))

def compare(ver1, ver2):
    t1 = ver1.split(".")
    t2 = ver2.split(".")

    # 버전의 길이가 다른 경우
    # ex (1.0.1, 1.0)
    # 길이가 짧은 버전에 임의로 0추가하여 길이를 맞추어 비교
    a = max(len(t1),len(t2))
    b = min(len(t1),len(t2))
    for i in range(a-b):
        t1.append("0")
        t2.append("0") 

    for i in range(a):
        if t1[i] > t2[i]:
            return ver1 + " > " + ver2

        if t1[i] < t2[i]:
            return ver2 + " > " + ver1

print(compare("0.0.2","0.0.1"))
print(compare("1.0.3","1.0.10"))
print(compare("1.1.99","1.2.0"))
print(compare("1.0.1","1.1"))
print(compare("1.0.1","1.0"))

version1=input("버전1 입력: ")
version2=input("버전2 입력: ")
temp1=list(version1)
temp2=list(version2)
v1=""
v2=""
while temp1.count('.'):
    temp1.remove('.')
while temp2.count('.'):
    temp2.remove('.')
for i in temp1:
    v1=v1+i
for j in temp2:
    v2=v2+j
if len(v1)<len(v2):
    v1=v1+(len(v2)-len(v1))*'0'
elif len(v1)>len(v2):
    v2=v2+(len(v1)-len(V2))*'0'
if int(v1)>int(v2):
    print("{0} > {1}".format(version1,version2))
elif int(v2)>int(v1):
    print("{0} > {1}".format(version2,version1))
else:
    print("{0} = {1}".format(version1,version2))

def func1(a, b, len_0):
    for i in range(len_0):
        a[i] = int(a[i]); b[i] = int(b[i])
        if a[i] > b[i]:
            return '>'
        elif a[i] < b[i]:
            return '<'
    return '='
a_0 = ''
b_0 = ''
#i = input().split(' ')
i = '1.0.10 1.0.3'
i = i.split(' ')
a = i[0]; b = i[1]
a = a.split('.'); b = b.split('.')
if len(a) > len(b):
    len_0 = int(len(a))
else:
    len_0 = int(len(b))
k = func1(a, b, len_0)
for i in range(len_0):
    a[i] = str(a[i]); b[i] = str(b[i])
for i in range(len_0):
    a_0 += a[i]+'.'
    b_0 += b[i]+'.'
print(a_0[:-1],k,b_0[:-1])

PHP

$fn = function(string $i, string $j) : string {
    $arr_i = explode('.', $i);
    $arr_j = explode('.', $j);

    $len = max(count($arr_i), count($arr_j));

    foreach (range(0, $len - 1) as $k) {
        $arr_i[$k] = isset($arr_i[$k]) ? $arr_i[$k] : 0;
        $arr_j[$k] = isset($arr_j[$k]) ? $arr_j[$k] : 0;

        if ($arr_i[$k] === $arr_j[$k]) {
            continue;
        }
        if ($arr_i[$k] > $arr_j[$k]) {
            return "$i > $j";
        }
        if ($arr_i[$k] < $arr_j[$k]) {
            return "$i < $j";
        }
    };

    return "$i = $j";
};

print_r($fn('0.0.2', '0.0.1'));  // 0.0.2 > 0.0.1
print_r($fn('1.0.10', '1.0.3')); // 1.0.10 > 1.0.3
print_r($fn('1.1', '1.0.1'));    // 1.1 > 1.0.1
print_r($fn('1.2', '1.0.1'));    // 1.2 > 1.0.1
print_r($fn('1.0.9', '2.0.1'));  // 1.0.9 < 2.0.1
print_r($fn('1.2.0', '1.1.99')); // 1.2.0 > 1.1.99
print_r($fn('1.1', '1.1.1'));    // 1.1 < 1.1.1
print_r($fn('1.1', '1.1.0'));    // 1.1 = 1.1.0

# Comparing_Version
first = input("Input first version = ")
second = input("Input second version = ")
a = list(map(int, list(first.split('.'))))
b = list(map(int, list(second.split('.'))))
for i in range(len(a)):
    if a[i] == b[i]:
        continue
    elif a[i] > b[i]:
        print("%s > %s" %(first, second))
        break
    else:
        print("%s < %s" % (first, second))
        break

a = input("첫번째 버전(x.x.x) : ")
b = input("두번째 버전(x.x.x) : ")

a_1 = a.split('.')
b_1 = b.split('.')

for i in range(max(len(a_1),len(b_1))):
    if int(a_1[i]) > int(b_1[i]):
        print(a ,">", b)
        break
    elif int(a_1[i]) < int(b_1[i]):
        print(a ,"<", b)
        break
    elif int(a_1[i]) == int(b_1[i]):
        continue
print(a, '=', b)

#버전비교
a= input("A 버전을 입력해 주세요:")
b= input("B 버전을 입력해 주세요:")
alist=a.split('.')
blist=b.split('.')

for n in range(0,len(alist)):
    if int(alist[n]) < int(blist[n]):
        print("B버전이 더 최신입니다.")
        break
    elif int(alist[n]) > int(blist[n]):
        print("A버전이 더 최신입니다.")
        break
    elif int(alist[n]) == int(blist[n]):
        if n==len(alist)-1:
            if len(alist)==len(blist):
                print("두 버전이 같습니다.")
            elif int(blist[n+1]) >0:
                print("B버전이 더 최신입니다.")

package practiceLv1;
import java.util.*;
public class 버전비교 {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.print("Plaeas wirte the version : ");
        String a = scan.nextLine();
        System.out.print("Plaeas wirte the version : ");
        String b = scan.nextLine();
        String[] first1 = a.split("\\.");
         int[] first2 = Arrays.stream(first1).mapToInt(Integer::parseInt).toArray();
         //String배열을 int배열로 변환
        String[] second1 = b.split("\\.");
         int[] second2 = Arrays.stream(second1).mapToInt(Integer::parseInt).toArray();
         for(int i=0; i<3; i++) {
                if(first2[i]>second2[i]) {
                    System.out.println("First version is recent");
                    break;
            }
                if(first2[i]<second2[i]) {
                    System.out.println("Second version is recent");
                    break;
                }
            }
        }
    }

a = '1.1' b = '1.0.1'

a_list = a.split('.') b_list = b.split('.')

def compare(): for i in range(len(a_list)): if int(a_list[i]) > int(b_list[i]): print("a > b") break elif int(a_list[i]) < int(b_list[i]): print("b > a") break compare()```{.python}

v1=list(map(str,input("버전1(ex-1.0.0)을 입력하십시오: ").split(".")))
v2=list(map(str,input("버전2(ex-1.0.0)을 입력하십시오: ").split(".")))
for n in range(min(len(v1),len(v2))):
    if int(v1[n])>int(v2[n]):
        print(".".join(v1)+" > "+".".join(v2))
        break  #(수정1) 1.2.0과 1.1.99를 비교했을 때 1.2.0>1.1.99와 1.2.0<1.1.99를 출력하게 되어 break를 넣음
    if int(v1[n])==int(v2[n]):
        continue
    if int(v1[n])<int(v2[n]):
        print(".".join(v1)+" < "+".".join(v2))
        break #(수정2)

var input1 = prompt("What is the First Version?");
var input2 = prompt("What is the Second Version?");
var a = [];
var b = [];
var c = [];
var Result = [];
console.log("First Version is " + input1)
console.log("Second Version is " + input2)
if(input1===input2) console.log("The First Version is equal to the Second Version");

for(var i = 0; i < input1.split('.').length; i++){
    if(input1.split('.')[i] > input2.split('.')[i]) Result.push('input1');
    else if(input1.split('.')[i] < input2.split('.')[i]) Result.push("input2");
    else if(input1.split('.')[i] === input2.split('.')[i]) Result.push("equal");

    if(Result[i] === 'input1') a.push('input1');
    else if(Result[i] === 'input2') b.push('input2')

}
if(a.length > b.length) console.log("The First Version is a recent version");
if(a.length < b.length) console.log("The Second Version is a recent version");

m1 = input("입력: ")
n1 = input("입력: ")

m2 = m1.split(".")
n2 = n1.split(".")

m = list(map(int, m2))
n = list(map(int, n2))

if m > n:
    print('{} > {}'. format(m1,n1))
elif m == n:
    print('{} = {}'. format(m1,n1))
else:
    print('{} < {}'. format(m1,n1))

ver1=input("ver1:") ver2=input("ver2:")

t1 = ver1.split(".")

t2 = ver2.split(".")

a = max(len(t1),len(t2))

b = min(len(t1),len(t2))

for i in range(a-b): t1.append("0") t2.append("0")

for i in range(min(len(t1),len(t2))):

if t1[i] > t2[i] :

    print ("V1")

elif t1[i] == t2[i] :

    continue

else:
    print ("V2")

a = input() b = input()

a_1 = a.split('.') b_1 = b.split('.')

for i in a_1: for j in b_1: i = int(i, 10) j = int(j, 10) if len(a_1[0]) > len(b_1[0]): print(a, '>', b) break elif len(a_1[0]) < len(b_1[0]): print(a, '<', b) break else: if len(a_1[1]) > len(b_1[1]): print(a, '>', b) break elif len(a_1[1]) < len(b_1[1]): print(a, '<', b) break else: if len(a_1[2]) > len(b_1[2]): print(a, '>', b) break elif len(a_1[2]) < len(b_1[2]): print(a, '<', b) break else: print(a, '=', b) break

파이썬 3.7

ver1 = '1.2.0'
ver2 = '1.1.99'

ver1_ = list(map(int, ver1.split(".")))
ver2_ = list(map(int, ver2.split(".")))

for i in range(min(len(ver1_), len(ver2_))):
    if ver1_[i] > ver2_[i]:
        print('%s > %s' % (ver1, ver2))
        break
    elif ver1_[i] == ver2_[i]:
        if i == min(len(ver1_), len(ver2_))-1:
            print('%s = %s' % (ver1, ver2))
        continue
    else:
        print('%s < %s' % (ver1, ver2))
        break

ver1, ver2 = input().split()
ver1_lst = list(map(int,ver1.split('.')))
ver2_lst = list(map(int,ver2.split('.')))

i=0

while i < min(len(ver1_lst), len(ver2_lst)):

    if ver1_lst[i]>ver2_lst[i]:
        print('.'.join(map(str,ver1_lst)),'>','.'.join(map(str,ver2_lst)))
        break

    if ver1_lst[i]<ver2_lst[i]:
        print('.'.join(map(str,ver1_lst)),'<','.'.join(map(str,ver2_lst)))
        break
    else:i+=1

python 3.8

a='2.0.11, 1.3.'.split(', ')
b=[ ]
for i in a:
  c=i.split(".")  
  if len(c) == 2:  
      c.append(' ') 
  b = b + c
print('.'.join(b[:3]),['<','>'][ (b[0] > b[3]) or (b[0] == b[3] and b[1] > b[4]) or (b[0] == b[3] and b[1] == b[4] and b[2]>=b[5])],'.'.join(b[3:]))

---------------

from itertools import zip_longest
a='2.0.11,1.30'.split(',')
b=zip_longest(a[0].split('.'),a[1].split('.'),fillvalue=0)
for x, y in b:
  if x > y:
    c='>'
    break
  if x < y:
    c='<'
    break
  if x == y:
    c = '='
print(a[0],c,a[1])

def ver_comp(ver1,ver2):
    ver1_split = ver1.split('.')
    ver1_join = float('0.'+''.join(ver1_split))
    ver2_split = ver2.split('.')
    ver2_join = float('0.'+''.join(ver2_split))
    if ver1_join > ver2_join:
        print(ver1,">",ver2)
    elif ver1_join == ver2_join:
        print(ver1,"=",ver2)
    else:
        print(ver1,"<",ver2)

a='0.0.2.99.1234145'
b='0.0.4.0'
p=a.split('.')
q=b.split('.')
n=0
k=0
if len(p)>=len(q):   
    for i in range(len(q)):
        v=int(p[i])-int(q[i])
        if v<0:
            k+=1
            print('b의 버전이 높습니다.')
            break
        elif v==0:
            pass
        else:
            k+=1
            print('a의 버전이 높습니다.')
            break
    if k==0:
        print('a의 버전이 높습니다.')
    else:
        pass


else:   
    for i in range(len(q)):
        v=int(p[i])-int(q[i])
        if v<0:
            k+=1
            print('a의 버전이 높습니다.')
            break
        elif v==0:
            pass
        else:
            k+=1
            print('b의 버전이 높습니다.')
            break
    if k==0:
        print('b의 버전이 높습니다.')
    else:
        pass

파이썬 입니다.

version1 = input("첫번째 버전 입력") 
version2 = input("두번째 버전 입력")
version1_slice=version1.split('.')
version2_slice=version2.split('.')
version_length = max(len(version1_slice), len(version2_slice)) # 입력된 버전정보의 길이가 큰것을 찾음

for i in range(version_length): # version 길이가 긴것까지 비교
    if i !=version_length-1: # 마지막 수가 아닐때
        if int(version1_slice[i]) > int(version2_slice[i]):
            print("%s > %s" %(version1,version2))
            break  # 높은 버전을 찾았으면 다음 수는 검사하지 않고 종료
        elif int(version1_slice[i]) < int(version2_slice[i]):
            print("%s > %s" %(version2,version1))
            break
        elif int(version1_slice[i]) == int(version2_slice[i]):
            continue
    else : # 마지막 검사전까지 모두 똑같을때 
        if int(version1_slice[i]) > int(version2_slice[i]):
            print("%s > %s" %(version1,version2))
        elif int(version1_slice[i]) < int(version2_slice[i]):
            print("%s > %s" %(version2,version1))
        elif int(version1_slice[i]) == int(version2_slice[i]):
            print("%s ==%s" %(version1,version2))

입력된 두 버전을 . 를 기준으로 쪼개서 맨앞부터 비교하였습니다. 만약 동일 version일경우 == 출력되게했습니다.

A_ver=input("A_version : ")
B_ver=input("B_version : ")
list_a=A_ver.split('.')
list_b=B_ver.split('.')
if len(list_a)<len(list_b):
    list_a.append('0')
elif len(list_a)>len(list_b):
    list_b.append('0')

for i in range(3):
    if list_a[i]>list_b[i]:
        print("{} > {}".format(A_ver,B_ver))
        break
    elif list_a[i]<list_b[i]:
        print("{} < {}".format(A_ver, B_ver))
        break

a=input(' input 1st version : ')
b=input(' input 2nd version : ')

aa=a.split('.')
bb=b.split('.')
n=0
try:

    for i in range(max(len(aa),len(bb))):
        if aa[i]>bb[i]:
            print('1st가 뒷버전')
            break
        elif aa[i]<bb[i]:
            print('1st가 먼저버전')
            break
        else:
            n+=1
            pass

    if n==max(len(aa),len(bb)):
        print('동일버전')
except:
    if len(aa)>len(bb):
        print('1st가 뒷버전')
    else:
        print('1st가 먼저버전')

i,j=input().split()

max=1

k=len(i)
h=len(j)

if k>h :
    max=h
else :
    max=k

for r in range(0,max):
    if i[r] is not j[r]:
        if int(i[r])>int(j[r]) :
           print('%s>%s' %(i,j))
           break
        else :
            print('%s>%s' %(j,i))
            break

#파이썬

def ver_list(a):                # 각 버전문자열을 리스트로 변환해주는 함수
    a=a.split('.')
    for i in range (len(a)):
        a[i]=int(a[i])
    return(a)

def ver_com(x,y):               # 버전을 비교해주는 함수
    xx,yy=x,y
    x,y=ver_list(x),ver_list(y)   

    if len(x)>len(y):                       #비교를 위하여 두개 버전의 .(점)의 갯수를 맞추어 줌
        for i in range (0,(len(x)-len(y))):
            y.append(0)
    elif len(y)>len(x):
        for i in range (0,(len(y)-len(x))):
            x.append(0)

    i=0
    while (i<=len(x)-1):
        if x[i]>y[i]:
            print(xx,'>',yy)
            break
        elif x[i]<y[i]:
            print(xx,'<',yy)
            break
        i+=1

ver_com('0.0.2','0.0.1')
ver_com('1.0.3','1.0.10')
ver_com('1.2.0','1.1.99')
ver_com('1.0.1','1.1')
ver_com('0.0.2','0.0.1.1')

파이썬으로 작성했습니다.

a = input("input ver a")
b = input("input ver b")

list_a = a.split(".")
list_b = b.split(".")

def check_num(x):
    if len(x) == 2:
        x.append(0)
    return x

a_new = list(map(int,check_num(list_a)))
b_new = list(map(int,check_num(list_b)))


if a_new == b_new:
    print("these are same version.")
else:
    for num in range(0,3):
        if a_new[num] < b_new[num]:
            print(f"{a} < {b}")
            break
        elif a_new[num] > b_new[num]:
            print(f"{a} > {b}")
            break
        else:
            continue

ver1 = input("First version : ")
ver2 = input("Second version : ")

a = ver1.split(".")
b = ver2.split(".")

for i in range(0, 5):
    if int(a[i]) > int(b[i]):
        print ("%s > %s" %(ver1, ver2))
        break
    if int(b[i]) > int(a[i]):
        print("%s > %s" % (ver2, ver1))
        break

스플릿하면 문자열이 되는줄 처음 알았네요... int를 안적으면 특정 숫자에서 제대로 표시가 안되요ㅠㅠ

import java.util.Scanner;

public class Q097 {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        System.out.print("1.ver? : ");
        String inputVer1 = scan.next();
        String[] ver1 = inputVer1.split("\\.");

        System.out.print("2.ver? : ");
        String inputVer2 = scan.next();
        String[] ver2 = inputVer2.split("\\.");

        String result = "";

        for (int i = 0; i < Math.min(ver1.length, ver2.length); i++) {
            if (Integer.parseInt(ver1[i]) > Integer.parseInt(ver2[i])) {
                result = inputVer1 + " > " + inputVer2;
                System.out.println(result);
                break;
            } else if (Integer.parseInt(ver1[i]) < Integer.parseInt(ver2[i])) {
                result = inputVer1 + " < " + inputVer2;
                System.out.println(result);
                break;
            }
        }
        scan.close();
    }
}

java

v1 = input()
v2 = input()

v1_s = v1.split(".")
v2_s = v2.split(".")

if v1_s[0] > v2_s[0]:
    print(v1+">"+v2)
elif v1_s[0] < v2_s[0]:
    print(v1+"<"+v2)
else:
    if v1_s[1] > v2_s[1]:
        print(v1+">"+v2)
    elif v1_s[1] < v2_s[1]:
        print(v1+"<"+v2)
    else:
        if v1_s[2] > v2_s[2]:            
            print(v1+">"+v2)
        elif v1_s[2] < v2_s[2]:
            print(v1+"<"+v2)
        else:
            print(v1+"="+v2)


정말 원초적으로 풀었네요ㅠㅠ
실력이 아직 많이 부족합니다

n=input().split(",")
version_list=[i.split(".") for i in n]
first=list(map(int,version_list[0]))
second=list(map(int,version_list[1]))
len_list=[len(first),len(second)]
len_list.sort()
for i in range (0,len_list[0]):
    if first[i]>second[i]:
        print(n[0]+">"+n[1])
        break
    if first[i]<second[i]:
        print(n[1]+">"+n[0])
        break
    else:
        pass

배열을 사용하면 메모리를 많이 잡아먹고 느려서 최대한 자제하려고 하는데 배열을 안쓰고하려면 정답이 전혀 생각안나네요 ㅜㅜ 그래도 최대한 구색맞춰서 풀어보려했습니다

ver_list = ['3.2.3', '3.0.1']

check1 = ver_list[0].split('.')
check2 = ver_list[1].split('.')

count = 0

for x in range(3):
    if check1[x] > check2[x]:
        print(ver_list[0],'>',ver_list[1])
        break
    elif check1[x] < check2[x]:
        print(ver_list[0],'<',ver_list[1])
        break
    else:
        count += 1

if count == 3:
    print(ver_list[0], '=', ver_list[1])

파이썬 3입니다.

import random as r
v1 = [r.randint(1,10) for i in range(10)]
v2 = [r.randint(0,100) for i in range(10)]
v3 = [r.randint(0,100) for i in range(10)]
ver = sorted([f'{v1[i]}.{v2[i]}.{v3[i]}' for i in range(10)], reverse=True)
print(ver)
for i in range(9) :
    print(f'{ver[i]}>{ver[i+1]}')

파이썬 판다스로 빅데이터 공부하고 있는 김에 판다스 모듈로 해봤습니다. 아직 초보라 미흡하니까 피드백해주시면 열심히 반영할게요.

import pandas as pd

a= input("Enter a version: ")
b=input("비교할 version: ")

A=a.split('.')
B=b.split('.')

def aa(L):
    if len(L)!=3:
        L.append('0')

aa(A)
aa(B)

df =  pd.DataFrame({'a' : A, 'b' : B}, index=[1,2,3])

for i in range(1,4):
    if int(df['a'][i])==int(df['b'][i]):
        continue
    elif int(df['a'][i])>int(df['b'][i]):
        print(a+">"+b)
        break
    else:
        print(a+"<"+b)
        break

v1 = input('버전을 입력하세요>> ')
v1_s = v1.split('.') + ['0']
v2 = input('버전을 입력하세요>> ')
v2_s = v2.split('.')+ ['0']

if int(v1_s[0]) > int(v2_s[0]):
    print(v1, '>', v2)

elif int(v1_s[0]) == int(v2_s[0]) and int(v1_s[1]) > int(v2_s[1]):
    print(v1, '>', v2)


elif int(v1_s[0]) == int(v2_s[0]) and int(v1_s[1]) == int(v2_s[1]) and int(v1_s[1]) > int(v2_s[1]):
    print(v1, '>', v2)

else:
    print(v1, '<', v2)

초보라 그냥 답을 구하는 수준에 만족합니다. 다른 분의 코드를 보면서 정말 감탄하고 있습니다.

public static void main(String[] args) {

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

        Scanner scan = new Scanner(System.in);

            for(int i = 0; i < 2; i++){         
                System.out.printf("%d 버젼 입력 : ", (i+1));
                String version = scan.next();
                String modVersion = version.replace(".", "");

                if(modVersion.length() != 4) {
                    int ediVersion = Integer.parseInt(modVersion);
                    vList.add((int)(ediVersion*Math.pow(10, 4-modVersion.length())));                   
                }else {
                    int ediVersion = Integer.parseInt(modVersion);
                    vList.add(ediVersion);
                }
            }
            int max = Collections.max(vList);
            System.out.printf("%d 버젼이 최신.", (vList.indexOf(max)+1));

    }

a,b=map(str, input().split())
if a==b:
    print(a+'='+b)
else:
    if a>b:
        print(a+'>'+b)
    else:
        print(a+'<'+b)

import java.util.Scanner;

public class version {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        System.out.print("첫번째 버전을 입력 : ");
        String a = sc.nextLine();
        System.out.print("두번째 버전을 입력 : ");
        String b = sc.nextLine();
        String[] a1 = a.split("[.]");
        String[] b1 = b.split("[.]");
        for(int i = 0; i<Math.min(a1.length, b1.length);i++) {
                if(Integer.parseInt(a1[i])>Integer.parseInt(b1[i])&&i==(Math.min(a1.length, b1.length)-1)) {
                    System.out.println(a + ">" + b);
                }
                else if(Integer.parseInt(a1[i])<Integer.parseInt(b1[i])&&i==(Math.min(a1.length, b1.length)-1)){
                    System.out.println(a + "<" + b);
                }
                else if(Integer.parseInt(a1[i])==Integer.parseInt(b1[i]) && 
                        (i==Math.min(a1.length, b1.length)-1)) {
                    if(a1.length>b1.length) {
                        System.out.println(a + ">" + b);
                    }
                    else if(a1.length<b1.length){
                        System.out.println(a + "<" + b);

                    }
                    else {
                        System.out.println(a + "=" + b);

                }

                }


        }
    }

class ComparingMachine:
    def __init__(self):
        pass
    def doCompare(self,an,bn):
        a = an.split(".")
        if len(a)<3:
            for i in range(len(a),3):
                a.append("0")
        b = bn.split(".")
        if len(b)<3:
            for i in range(len(b),3):
                b.append("0")
        i = 0
        while True:
            if int(a[i])>int(b[i]):
                print (an,">",bn)
                break
            elif int(a[i])<int(b[i]):
                print(an, "<", bn)
                break
            else:
                i += 1
            if i==3:
                break

a = ComparingMachine()
a.doCompare("0.0.2","0.0.1")
a.doCompare("1.0.10","1.0.3")
a.doCompare("1.2.0","1.1.99")
a.doCompare("1.1","1.0.1")

ver_1 = str(input("버전을 입력하시오(ex. 1.0.1)"))
ver_2 = str(input("비교 버전을 입력하시오(ex. 1.0.1)"))

c = ver_1.split('.')
d = ver_2.split('.')


if int(c[0]) > int(d[0]):
    print(ver_1 + ">" + ver_2)

elif int(c[0]) == int(d[0]):
    if int(c[1]) > int(d[1]):
        print(ver_1 + ">" + ver_2)
    else :
        print(ver_1 + "<=" + ver_2)



elif int(c[0]) == int(d[0]):
    if int(c[1])== int(d[1]):
        if int(c[2]) > int(d[2]):
            print(ver_1 + ">" + ver_2)
        else :
            print(ver_1 + "<=" + ver_2)

else :
    print(ver_1 + "<=" + ver_2)

파이썬입니다, 버전이 같을땐 조건문을 어디에 넣어야 할지 모르겠네요..

pro_1 = input('Please input the version of a program 1: ').split('.')
pro_2 = input('Please input the version of a program 2: ').split('.')

for i in range(3):
    try:
        if int(pro_1[i]) > int(pro_2[i]):
            print('Program 1 is the newer version.')
            break
        elif int(pro_1[i]) < int(pro_2[i]):
            print('Program 2 is the newer version.')
            break

    # IN CASE INDEX 2, VERSION 1.1, COMPARE THE LENGTH OF LISTS.
    except IndexError:
        if len(pro_1) > len(pro_2):
            print('Program 1 is the newer version')
        elif len(pro_1) < len(pro_2):
            print('Program 2 is the newer version')

    # IN CASE VALUEERROR OCCURS FROM TYPOS e.g 1.1.
    except ValueError:
        pass

이거 하다보니 comparewith 메서드가 되어버렸네요.

ver1 이 ver2 보다 크면 1, 작으면 -1, 같으면 0가 나옵니다.

def custom_zfill(x_value, max):
    return int("{x:0<{m}}" .format(x=x_value, m=max))

def compare_version(ver1, ver2):
    ver1 = ver1.split(".")
    ver2 = ver2.split(".")
    if len(ver1) < 3: ver1.append("0")
    if len(ver2) < 3: ver2.append("0")
    result = 0

    for i in range(0, 3):
        if int(ver1[i]) == int(ver2[i]):
            continue
        else:
            max_len = 0
            if len(ver1[i]) != len(ver2[i]):
                if len(ver1[i]) > len(ver2[i]):
                    max_len = len(ver1[i])
                else:
                    max_len = len(ver2[i])

            if custom_zfill(ver1[i], max_len) == custom_zfill(ver2[i], max_len):
                result = 0
                break
            else:
                if custom_zfill(ver1[i], max_len) > custom_zfill(ver2[i], max_len):
                    result = 1
                    break
                else:
                    result = -1
                    break

    return result

case1 = ["0.1.20", "0.1.2"] # OK
case2 = ["1.0.20", "0.1.2"] # OK
case3 = ["1.2.20", "0.1.2"] # OK
case4 = ["1.1", "0.1.2"] # OK
case5 = ["01.1.20", "10.1.2"] # OK
case6 = ["1.2.099", "01.02.99"] # OK
case7 = ["1.2.098", "0.2.1"] # OK
case8 = ["1.1.0", "1.01"] # OK
case_list = [case1, case2, case3, case4, case5, case6, case7, case8,]

for i in case_list:
    if compare_version(i[0], i[1]) == 0:
        print("{0} == {1}" .format(i[0], i[1]))
    elif compare_version(i[0], i[1]) > 0:
        print("{0} > {1}" .format(i[0], i[1]))
    else:
        print("{0} < {1}" .format(i[0], i[1]))

a,b=map(str,input().split())

list1=[]
list2=[]

for i in range(len(a)):
  list1.append(a[i])

for i in range(len(b)):
  list2.append(b[i])


if len(list1)!=len(list2):
  if len(list1)>len(list2):
    for i in range(len(list1)-len(list2)):
      list2.append("0")
  else:
    for i in range(len(list2)-len(list1)):
      list1.append("0")

for i in range(0,len(list1),2):
  if list1[i]>list2[i]:
    print(a+" > "+b)
    break
  elif list1[i]<list2[i]:
    print(a+" < "+b)
    break

ver1 = input("type version1: ")
ver1_int = [int(v) for v in ver1.split('.')]
len1 = len(ver1_int)
ver2 = input("type version2: ")
ver2_int = [int(v) for v in ver2.split('.')]
len2 = len(ver2_int)

i=0
while i < min(len1,len2):
    if ver1_int[i] > ver2_int[i]:
        print(ver1, '>', ver2)
        break
    elif ver2_int[i] > ver1_int[i]:
        print(ver2, '>', ver1)
        break
    elif ver1 == ver2:
        print(ver1, '=', ver2)
        break
    i += 1

if ver1_int[:min(len1,len2)] == ver2_int[:min(len1,len2)]:
    if len1>len2:
        print(ver1, '>', ver2)
    elif len2>len1:
        print(ver2, '>', ver1)

a = input("version 1:")
b = input("version 2:")

if int(a.split(".")[0]) > int(b.split(".")[0]) :
    print("{} {} {}".format(a, ">", b))
elif int(a.split(".")[0]) < int(b.split(".")[0]) :
    print("{} {} {}".format(a, "<", b))
else :
    if int(a.split(".")[1]) > int(b.split(".")[1]) :
        print("{} {} {}".format(a, ">", b))
    elif int(a.split(".")[1]) < int(b.split(".")[1]) :
        print("{} {} {}".format(a, "<", b))
    else : 
        if int(a.split(".")[2]) > int(b.split(".")[2]) :
            print("{} {} {}".format(a, ">", b))
        elif int(a.split(".")[2]) < int(b.split(".")[2]) :
            print("{} {} {}".format(a, "<", b))

def compareVirsion(a,b):
    first = a.split(".")
    second = b.split(".")
    result = str(a)+" > "+str(b) if int(first[0]) > int(second[0]) else str(a)+" < "+str(b)
    if int(first[0]) == int(second[0]) and int(first[1]) > int(second[1]):
        result = str(a) + " > " + str(b)
    elif int(first[0]) == int(second[0]) and int(first[1]) == int(second[1]) and int(first[2]) > int(second[2]):
        result = str(a) + " > " + str(b)
    else:
        result = str(a) + " < " + str(b)
    print(result)


compareVirsion("0.0.2","0.0.1")
compareVirsion("1.0.10","1.0.3")
compareVirsion("1.2.0","1.1.99")
compareVirsion("1.1","1.0.1")

str1 , str2 = input("two string: ").split()

lst1 = list(map(int,str1.split(".")))
lst2 = list(map(int,str2.split(".")))

for i in range(3):
    if lst1[i] == lst2[i]:
        continue
    elif lst1[i] > lst2[i]:
        print("{0} > {1}".format(str1, str2))
        break
    else:
        print("{0} < {1}".format(str1, str2))
        break

def Split_Versus(a,b):

  c=a.split(".")

  d=b.split(".")

  for i in range(min(len(c),len(d))):

    if int(c[i])>int(d[i]):

      print("{0} > {1}".format(a,b))

      break
    elif int(c[i])<int(d[i]):

      print("{0} < {1}".format(a,b))

      break

    elif i==min(len(c),len(d)):

      if len[c]<len[d]:

        print("{0} < {1}".format(a,b))

     else:

        print("{0} > {1}".format(a,b))


k="1.0.2"

n="0.0.1"

Split_Versus(k,n)

def compare(v1,v2):
    x1= v1.split('.')
    x2 = v2.split('.')
    for a,b in zip(x1,x2):
        if int(a)>int(b):
            return '{}>{}'.format(v1,v2)
        elif int(a)<int(b):
            return '{}<{}'.format(v1,v2)

a = '1.1'
b = '1.0.1'

new_a = a.split('.')
new_b = b.split('.')
i = 0


while True:
    if len(new_a) == len(new_b):
        if i < len(new_a) - 1:
            if int(new_a[i]) > int(new_b[i]):
                print('a > b')
                break
            elif int(new_a[i]) < int(new_b[i]):
                print('a < b')
                break
            elif int(new_a[i]) == int(new_b[i]):
                i += 1
        elif i == len(new_a) - 1:
            if int(new_a[i]) > int(new_b[i]):
                print('a > b')
                break
            elif int(new_a[i]) < int(new_b[i]):
                print('a < b')
                break
            elif int(new_a[i]) == int(new_b[i]):
                print('a = b')
                break
    elif len(new_a) != len(new_b):
        if i < (min(len(new_a), len(new_b))):
            if int(new_a[i]) > int(new_b[i]):
                print('a > b')
                break
            elif int(new_a[i]) < int(new_b[i]):
                print('a < b')
                break
            elif int(new_a[i]) == int(new_b[i]):
                i += 1
        elif i == min(len(new_a), len(new_b)):
            if len(new_a) > len(new_b):
                print('a > b')
                break
            elif len(new_a) < len(new_b):
                print('a < b')
                break

split한 후 각 인덱스별로 비교하면서 결론 도출하는 형식입니다. 처음에 쉽다고 생각했는데 여러 예외상황이 생기면서 코딩만 쓸 데 없이 길어졌네요.. 예외상황 ) 버전이 서로 같을 때, 버전 길이가 다를 때 (1.1.2 와 1.1.2.4) 등

def check(a,b):
    if int(a) > int(b):
        return 1
    elif int(a) < int(b):
        return 2
    else:
        return 0

a,b = input().split()

a1 = a.split('.')
b1 = b.split('.')
result = []
for i in range(len(a1)):
    result.append(check(a1[i],b1[i]))

for i in result:
    if i == 0:
        continue
    elif i == 1:
        print(a + " > " + b)
        break
    else:
        print(a + " < " + b)
        break

def compare_f(fv1,fv2):
    if fv1.split('.')[0] > fv2.split('.')[0]:
        return '>'
    elif fv1.split('.')[0]< fv2.split('.')[0]:
        return '<'
    else:
        return compare_f(fv1.split('.',maxsplit=1)[1],fv2.split('.',maxsplit=1)[1])

v1 ='1.2.0'
v2 ='1.1.99'

print(v1+compare_f(v1,v2)+v2)

ver1, ver2 = input().split(' ')

def comp(ver1, ver2):
    ver1 = ver1.split('.')
    ver2 = ver2.split('.')
    output = '<'
    for i in range(3):
        try:
            if int(ver1[i]) > int(ver2[i]):
                print(ver1[i], ver2[i])
                output = '>'
                break
        except:
            pass

    return output

if comp(ver1, ver2) == '<':
    print(f'{ver2} > {ver1}')
else :
    print(f'{ver1} > {ver2}')

a = input().split('.')
b = input().split('.')

for i in range(len(a)):
    if int(a[i]) == int(b[i]):
        pass
    else:
        if int(a[i]) < int(b[i]):
            print(f"{'.'.join(b)} > {'.'.join(a)}")
        else:
            print(f"{'.'.join(a)} > {'.'.join(b)}")
        break

[파이썬]

def VerCompare(a, b):
    c = a.split('.')
    d = b.split(".")
    #  각 자리의 수를 따로 비교합니다
    for i in range(3):
        if int(c[i]) > int(d[i]):
            print("%s > %s" % (a, b))
            break
        elif int(c[i]) < int(d[i]):
            print("%s > %s" % (b, a))
            break
        else:  # c[i] == d[i]
            if i == 2:
                print("%s = %s" % (a, b))
            continue


VerCompare("0.0.2", "0.0.1")
VerCompare("1.0.10", "1.0.3")
VerCompare("1.2.0", "1.1.99")
VerCompare("1.1", "1.0.1")

def comp(ver1,ver2):
    ver_1 = ver1.split(".")
    ver_2 = ver2.split(".")

    if len(ver_1) > len(ver_2):
        for i in range(len(ver_1) - len(ver_2)):
            ver_2.append('0')
        for i in range(len(ver_1)):
            if int(ver_1[i]) > int(ver_2[i]):
                print("ver1이 더 큽니다")
                break

            elif int(ver_1[i]) < int(ver_2[i]):
                print("ver2가 더 큽니다")
                break

    elif len(ver_1) == len(ver_2):
        for i in range(len(ver_1) - len(ver_2)):
            ver_2.append('0')
        for i in range(len(ver_1)):
            if int(ver_1[i]) > int(ver_2[i]):
                print("ver1이 더 큽니다")
                break

            elif int(ver_1[i]) < int(ver_2[i]):
                print("ver2가 더 큽니다")
                break

    else:
        for i in range(len(ver_1) - len(ver_2)):
            ver_1.append('0')
            for i in range(len(ver_2)):
                if int(ver_1[i]) > int(ver_2[i]):
                    print("ver1이 더 큽니다")

                elif int(ver_1[i]) < int(ver_2[i]):
                    print("ver2가 더 큽니다")

comp('2.4.5','2.4')
comp('2.1.5','2.4')
comp('1.4.5','2.4')

def ves(data1,data2):
    A = data1.split('.')
    B = data2.split('.')
    i=0
    while i < len(A):
        if int(A[i])>int(B[i]):
            print("{}>{}".format(data1,data2))
            break
        elif int(A[i])==int(B[i]):
            i+=1
            continue
        else:
            print("{}<{}".format(data1,data2))
            break

ves("0.0.0.0.2","0.0.0.1")

def whoisfirst(A,B):
    A1 = A.split('.'); B1 = B.split('.')
    for i in range(len(A1)):
        if A1[i] > B1[i]:
            print('%s > %s' %(A,B))
            break
        elif B1[i] > A1[i]:
            print('%s > %s' %(B,A))
            break
        else:
            i = i+1
    if i == 3:
        print('A=B')

A = '1.1.23'
B = '1.1.23'
whoisfirst(A,B)

v1=input('버전 입력')
v2=input('버전 입력')   #버전 입력 (따로 저장하는 이유: 결과 출력시 값이 변해서 나오는 것을 방지)

lv1=v1.split('.')
lv2=v2.split('.')       #버전을 리스트화한 변수 저장

x=0                     #자릿값 차이 변수

#버전의 자릿수가 다를 경우 맞춰주기(생략하면 1.0과 1.0.0 비교할 때에 오류)
if len(lv1)>len(lv2) :
    x=len(lv1)-len(lv2)
    for i in range(x):
        lv2.append('0')
elif len(lv1)<len(lv2):
    x=len(lv2)-len(lv1)
    for i in range(x):
        lv1.append('0')

#버전값 비교
for i in range(3):
    if int(lv1[i]) > int(lv2[i]) :
        print(v1,'>',v2)
        break
    if lv1[i] == lv2[i]:
        pass
    if int(lv1[i]) < int(lv2[i]) :
        print(v2,'>',v1)
        break

if lv1 == lv2:
    print(v1,'=',v2)

간단한 문제라고 생각했는데, 버전이 같음에도 자릿수가 달라서 오류가 생기는 경우를 생각하지를 못했네요. 결국 또 뱅뱅 돌아서 겨우겨우 올바른 코드를 작성했습니다.ㅠㅠ

const compareVersion = (a, b) => {
  let temp1 = a.split('.');
  let temp2 = b.split('.');
  const length = Math.max(temp1.length, temp2.length);
  for (let i=0; i<length; i++){
    const num1 = parseInt(temp1[i]) || 0;
    const num2 = parseInt(temp2[i]) || 0;
    if (num1 - num2) return num1 - num2;
  }
  return 0;
}

ver1 = input('ver1: ')
ver2 = input('ver2: ')

ver_list_1 = list(map(int, ver1.split('.')))
ver_list_2 = list(map(int, ver2.split('.')))

for i in range(len(ver_list_1)):
    if ver_list_1[i] > ver_list_2[i]:
        inequal = '>'
        break
    elif ver_list_1[i] == ver_list_2[i]:
        inequal = '='
        continue
    else:
        inequal = '<'
        break

print(ver1, inequal, ver2)

Python3입니다. Python2에 있던 cmp()처럼 왼쪽 버전이 높으면 1, 같으면 0, 오른쪽이 높으면 -1을 반환하는 cmpver()를 만들었습니다.

>>> def cmpver(a, b):
...     ver = lambda s: list(map(int, (s + '.0.0').split('.')[:3]))
...     cmp = lambda x, y: (x > y) - (x < y)
...     maj, min, mic = (cmp(ver(a)[i], ver(b)[i]) for i in range(3))
...     if maj != 0:
...         return maj
...     elif min != 0:
...         return min
...     else:
...         return mic
...
>>> cmpver('1.0.0', '1.0.23')
-1
>>> cmpver('1.1', '1.0.1')
1

ver는 세 자리 버전 번호 리스트를 만듭니다. 별도 함수로 작성하면 다음과 같습니다.

>>> def ver(s):
...     return list(map(int, (s + '.0.0').split('.')[:3]))
...
>>> ver('1.1')
[1, 1, 0]

cmp는 Python2에 있던 cmp()와 같은 역할입니다. (https://portingguide.readthedocs.io/en/latest/comparisons.html#the-cmp-function 참조)

a = input().split('.')
b = input().split('.')
compare = min(len(a),len(b))

i = 0
for i in range(compare):
    if a[i] > b[i]:
     print('.'.join(a)," > ",'.'.join(b))
     break
    elif a[i] < b[i]:
     print('.'.join(b)," > ",'.'.join(b))
     break
    else: i += 1

#version string의 각 digit을 integer의 합으로 변경.
strVersionA = input("Version A? ")
strVersionB = input("Version B? ")

listVersionA = strVersionA.split(".")
listVersionB = strVersionB.split(".")

nLenVersionA = len(listVersionA)
nLenVersionB = len(listVersionB)
nSumA = 0
nSumB = 0


for strDigit in listVersionA:
    nDigit = int(strDigit)
    nSumA += nDigit * (10 *(nLenVersionA-1))

for strDigit in listVersionB:
    nDigit = int(strDigit)
    nSumB += nDigit * (10 *(nLenVersionB-1))

if nSumA > nSumB:
    print(strVersionA, "is higher than", strVersionB)
else:
    print(strVersionB, "is higher than", strVersionA)    

def compare_version():
    ver_1 = input("1번 버전을 입력하세요 : ")
    ver_2 = input("2번 버전을 입력하세요 : ")
    list_1 = ver_1.split(".")
    list_2 = ver_2.split(".")
    l = max(len(list_1), len(list_2))
    for i in range(l):
        if list_1[i] > list_2[i]:
            print("{} > {}".format(ver_1, ver_2))
            break
        elif list_1[i] < list_2[i]:
            print("{} < {}".format(ver_1, ver_2))
            break



compare_version()

def version_check(x,y):
    x_s, y_s = x.split("."), y.split(".")

    for i in range(0,len(x_s)):
        x_s[i] = int(x_s[i])
    for i in range(0,len(y_s)):
        y_s[i] = int(y_s[i])

    x_s[0], x_s[1] = x_s[0] * 100, x_s[1] * 10
    y_s[0], y_s[1] = y_s[0] * 100, y_s[1] * 10

    if sum(x_s) > sum(y_s):
        print("{0} > {1}".format(x,y))
    else:
        print("{0} > {1}".format(y,x))

python 3.8.10 으로 작성되었습니다.

a = input("두 개의 버전을 입력 : ")
a = a.split(' ')


def comparison(a, n):
    if n == 1:
        print(a[0] + '>' + a[1])
    elif n == 0:
        print(a[0] + '<' + a[1])


v1 = a[0].split('.')
v2 = a[1].split('.')
print(v1, '\t', v2)

for i in range(3):
    try:
        if v1[i] > v2[i]:
            comparison(a, 1)
        elif v1[i] == v2[i]:
            pass
        else:
            comparison(a, 0)
    except:
        if len(v1) > len(v2):
            comparison(a, 1)
        else:
            comparison(a, 0)

a = input().split('.')
b = input().split('.')
if a > b:
    print(f'{a} > {b}')
elif a < b:
    print(f'{a} < {b}')

sample1 = "0.0.0.1.2.5.2.0"
sample2 = "0.0.3.1.2.5.2.0"

Sample1 = int("".join(sample1.split(".")))
Sample2 = int("".join(sample2.split(".")))

if Sample1 > Sample2:
    print(sample1, ">", sample2)
elif Sample1 < Sample2:
    print(sample1, "<", sample2)
else:
    print(sample1, "=", sample2)

static String comparison(String x, String y) {
        String[] a = x.split("[.]");
        String[] b = y.split("[.]");
        for (int i = 0; i < 5; i++) {
            if (a[i] == null)
                a[i] = "0";

            if (b[i] == null)
                b[i] = "0";

            if (!a[i].equals(b[i])) {
                if (Integer.parseInt(a[i]) < Integer.parseInt(b[i])) {
                    return x + " < " + y;
                } else
                    return x + " > " + y;
            }
        }
        return x + " == " + y;
    }

    public static void main(String[] args) {
        System.out.println(comparison("0.0.2", "0.0.1"));
        System.out.println(comparison("1.0.10", "1.0.3"));
        System.out.println(comparison("1.2.0", "1.1.99"));
        System.out.println(comparison("1.1", "1.0.1"));

    }

x1 = input("첫번째 버전을 입력해주세요 : ")
x2 = input("두번째 버전을 입력해주세요 : ")

y1 = x1.split(".")
y2 = x2.split(".")

if int(y1[0]) > int(y2[0]):
    print("%s > %s" % (x1,x2))
elif int(y1[1]) > int(y2[1]):
    print("%s > %s" % (x1,x2))
elif int(y1[2]) > int(y2[2]):
    print("%s > %s" % (x1,x2))
elif x1 == x2:
    print("%s = %s" %(x1,x2))
else:
    print("%s < %s" %(x1,x2))

a= input("A 버전 : ").split(".")
b= input("B 버전 : ").split(".")

def do(A, B):
    same = 0

    if len(A) > len(B):
        short, long = B, A
    elif len(A) < len(B):
        short, long = A, B
    else:
        short, long, same = B, A, len(A)-1


    for i in range(len(short)):
        if short[i] > long[i]:
            return print("{}가 최신버전".format(".".join(short)))
        elif short[i] < long[i]:
            return print("{}가 최신버전".format(".".join(long)))
        elif short[same] == long[same] and same != 0:
            return print("두 버전은 같은 버전입니다")

    print("{}가 최신버전".format(".".join(long)))

do(a,b)

a = "1.0"
b = "1.0.23"

def arr (a) :
    a1 = a.split(".")
    if len(a1) != 3 :
        a1.append('0')
    return a1

def solution (a,b) : 
    for i in range(len(a)) : 
        if a[i] > b[i] :
            print(a,">",b)
            break
        elif a[i] < b[i] :
            print(a,"<",b)
            break
        else : 
            if i == (len(a)-1) :
                print(a,"=",b)


a1 = arr(a)
b1 = arr(b)


solution(a1,b1)

리스트를 부등호로 비교할 때의 처리 과정과 버전 비교의 처리 과정이 같음을 이용했습니다. python 3.9.6입니다.

def version(a: str, b: str) -> int:
    a = [int(ver_num) for ver_num in a.split('.')]
    b = [int(ver_num2) for ver_num2 in b.split('.')]
    if len(a) < len(b):
        a += [0] * (len(b)-len(a))
    else:
        b += [0] * (len(a)-len(b))
    return 1 if a>b else 0 if a==b else -1

print('\n' + str(version(input(), input())))

ver_a = input('version_a 를 입력하시오')
ver_b = input('version_b 를 입력하시오')

ver_a_split = ver_a.split('.')
ver_b_split = ver_b.split('.')

if "".join(ver_a_split) < "".join(ver_b_split):
    print('ver_a < ver_b')

// Rust

// lexicographical comparison of arrays, vectors, slices

use std::str::FromStr; use std::num::ParseIntError;

fn main() {

let versions = vec![("0.0.2", "0.0.1"), ("1.0.10", "1.0.3"),
                    ("1.2.0", "1.1.99"), ("1.1", "1.0.1")];

for (v1_str, v2_str) in versions {

    //각 version을 vector(3개의 정수)로 변환
    let v1 = parse_version(v1_str).unwrap();
    let v2 = parse_version(v2_str).unwrap();

    // 두 vector간 비교
    let result;
    if v1 > v2 {
        result = '>';
    } else if v1 < v2 {
        result = '<';
    } else {
        result = '=';
    }
    println!("{} {} {}", v1_str, result, v2_str);
}

}

fn parse_version(v: &str) -> Result, ParseIntError> {

let mut vec = vec![];
for n in v.split('.') {
    vec.push(u8::from_str(n)?);
}

while vec.len() < 3 {
    vec.push(0);
}

Ok(vec)

}

def ver_comp (a, b):
    a1 = a.split('.')
    b1 = b.split('.')
    determiant = 0
    for i in range(min(len(a1), len(b1))):
        determinant = int(a1[i])-int(b1[i])
        if determinant == 0:
            continue
        else:
            break

    if determinant ==0 and len(a1) > len(b1): determinant = 1
    elif determinant == 0 and len (a1) < len(b1): determinant = -1


    if determinant == 0:print (a,'=',b)
    elif determinant < 0:print (a,'<',b)
    else:print(a,'>',b)

ver_comp('0.0.2','0.0.1')     
ver_comp('1.0.10','1.0.3')
ver_comp('1.2.0','1.1.99')
ver_comp('1.1','1.0.1')
ver_comp('1.1','1.1.2')

package org.javaturotials.ex;
import java.util.*;


public class test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        test al =new test();
        String v1 = "1.0.0";
        String v2= "1.0.23";
        String v3 = "1.1";
        al.cal(v1, v2);
        al.cal(v1, v3);
        al.cal(v2, v3);
    }

    public void cal(String a, String b) {
        String[] av = a.split("[.]");
        String[] bv =b.split("[.]");
        int i=0;
        while(true) {
            if(Integer.valueOf(av[i])==Integer.valueOf(bv[i])) {
                i++;
            }
            if(Integer.valueOf(av[i])>Integer.valueOf(bv[i])) {
                System.out.println(a + " > " + b);
                break;
            }
            if(Integer.valueOf(av[i])<Integer.valueOf(bv[i])) {
                System.out.println(a + " < " + b);
                break;
            }
            }
        }
    }

package com.algorithm.algorithmpractice.dojang;

public class VersionLatest {
    static String getLatest(String ver1, String ver2) {

        String[] arr1 = ver1.split("[.]");
        String[] arr2 = ver2.split("[.]");

        int length = arr1.length > arr2.length ? arr1.length : arr2.length;
        String late = "";
        for (int i = 0; i < length; i++) {
            try {
                if (Integer.parseInt(arr1[i]) > Integer.parseInt(arr2[i])) {
                    late = ver1;
                    break;
                } else if (Integer.parseInt(arr1[i]) < Integer.parseInt(arr2[i])) {
                    late = ver2;
                    break;
                }
            } catch (Exception e) {
                late = ver1.length() > ver2.length() ? ver1 : ver2;
            }
        }
        if (late.equals("")) {
            late = "equal";
        }
        return late;
    }

    public static void main(String[] args) {
        String version1 = "1.0.1";
        String version2 = "1.0.2.2";
        String result = getLatest(version1, version2);
        System.out.println("latest version: " + result);
    }
}

v1, v2 = str(input()), str(input())
a, b = v1.split('.'), v2.split('.')
if len(a) < len(b):
  n = len(a)
else:
  n = len(b)
for x in range(n-1):
  if a[x] == b[x]:
    if a[n-1] == b[n-1]:
      if len(a) > len(b):
        print('첫 번째 버전이 더 최신 버전입니다.')
        break
      elif len(a) < len(b):
        print('두 번째 버전이 더 최신 버전입니다.')
        break
      else:
        continue
  elif a[x] > b[x]:
    print('첫 번째 버전이 더 최신 버전입니다.')
    break
  elif a[x] < b[x]:
    print('두 번째 버전이 더 최신 버전입니다.')
    break

a = input('첫번째 버전을 입력하세요. : ')
b = input('두번째 버전을 입력하세요. : ')

A = a.split('.')
B = b.split('.')
while len(A) != len(B):
    if len(A) > len(B):
        B.append('0')
    else:
        A.append('0')

if A == B:
    print('같은 버전입니다.')
else:
    while A or B == True:
        Aa = int(A.pop(0))
        Bb = int(B.pop(0))
        if Aa == Bb: pass
        elif Aa > Bb:
            print(a,'>',b)
            break
        else:
            print(a,'<',b)
            break

cmd1 = input("첫번째 버전을 입력하시오 :")
cmd2 = input("두번째 버전을 입력하시오 :")

cmd1.split(".")
cmd2.split(".")

if cmd1 > cmd2:
    print("첫번째 버전이 더 최신버전입니다.")

else:
    print("두번째 버전이 더 최신버전입니다.")

파이썬으로 짠 코드입니다.

def comp_ver(a,b):
    if len(a)>len(b):
        b.append( '0' * (len(a)-len(b)) )
    elif len(b)>len(a):
        a.append( '0' * (len(b)-len(a)) )
    for i in range(len(a)):
        if a[i] > b[i]:
            result = a
            break
        elif a[i] < b[i]:
            result = b
            break
    return '.'.join(result)

v1 = input("버전 입력>> ").split('.')
v2 = input("비교할 버전 입력>> ").split('.')
print("최신 버전은 " + comp_ver(v1, v2))

파이썬 3.8.5

a='1.0'
b='1.1.1'
A="".join(a.split('.'))
B="".join(b.split('.'))
print(f'최신 버전 : {a if max(A,B)==A else b}')

하루 종일 고민 하다가 문득 max 함수가 문자도 비교가능하다는 게 떠올라 이용해 보았습니다. max함수를 사용하면 자릿수가 다른 문제도 한번에 해결 됩니다. 오류가 있다면 댓글 부탁 드립니다.

python

ver1 = input("첫 번째 버전을 입력하시오: ").split('.')
ver2 = input("두 번째 버전을 입력하시오: ").split('.')

for i in range(len(ver1)):
    if int(ver1[i]) > int(ver2[i]):
        print("첫 번째 버전이 더 높습니다.")
        break

    elif int(ver1[i]) < int(ver2[i]):
        print("두 번째 버전이 더 높습니다.")
        break

    else:
        continue

ver1=input('Please input version> ')
ver2=input('Please input version for compare> ')
ver1.replace('.','')
ver2.replace('.','')
n=min(len(ver1.replace('.','')),len(ver2.replace('.','')))
for i in range(n):
    if int(ver1.replace('.','')[i]) > int(ver2.replace('.','')[i]):
        print(ver1,'>',ver2)
        break
    elif int(ver1.replace('.','')[i]) < int(ver2.replace('.','')[i]):
        print(ver1,'<',ver2)
        break
    else :
        pass

if len(ver1.replace('.','')) > len(ver2.replace('.','')):
    print(ver1,'>',ver2)
else:
    print(ver1,'<',ver2)

Python. 'for'문을 이용해 동일 함수를 반복하는 연습이 되었습니다.

def ver_comp():
    a=input("첫 번째 프로그램의 버전을 입력해 주세요. : ")
    b=input("두 번째 프로그램의 버전을 입력해 주세요. : ")
    a_list=a.split(".") #a와 b를 "."을 기준으로 나누어 리스트화
    b_list=b.split(".")
    while True:
        for i in range(len(a_list)): #a를 기준으로 리스트의 길이만큼 함수 반복
            if int(a_list[i])>int(b_list[i]): #a와 b의 첫 번째 수를 비교
                return print(str(a)+" > "+str(b))
            elif int(a_list[i])<int(b_list[i]):
                return print(str(a)+" < "+str(b))
            else: #a와 b의 첫 번째 수가 같을 경우 i가 1 증가하여 다음 수를 비교
                pass
        if int(a_list[i-1])==int(b_list[i-1]): #두 버전이 동일할 경우
                return print(str(a)+" = "+str(b))

ver_comp()

import java.util.Scanner;

public class up010 { public static void main(String[] args) {

    String v1 = "";
    String v2 = "";
    Scanner scan = new Scanner(System.in);

    System.out.print("첫 번째 버전을 입력하세요: ");
    v1 = scan.next();

    System.out.print("두 번째 버전을 입력하세요: ");
    v2 = scan.next();

    compareVer(v1,v2);
}

public static void compareVer(String v1, String v2) {

    String[] stringArr1 = v1.split("\\.");
    String[] stringArr2 = v2.split("\\.");

    for(int i=0; i<3; i++) {

        if(Integer.parseInt(stringArr1[i]) > Integer.parseInt(stringArr2[i])) {
        System.out.printf("버전 %s가 더 최신입니다.\n", v1);
        break;
        }else if(Integer.parseInt(stringArr1[i]) < Integer.parseInt(stringArr2[i])) {
        System.out.printf("버전 %s가 더 최신입니다.\n", v2);
        break;
        }else {
         continue;
        }
    }
}

}

자바로 작성하였습니다

```C언어로 작성하였습니다. strtok특성상 연속으로는 사용할 수 없어 조금 비효율적으로 작성한 것 같습니다.

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

void compare_ver(char, char);

int main() {

char v1[10];
char v2[10];

printf("첫 번째 버전을 입력하세요. : ");
scanf("%s", v1);

printf("두 번째 버전을 입력하세요. : ");
scanf("%s", v2);

compare_ver(v1, v2);

return 0;

}

void compare_ver(char v1, char v2) {

char* ptr1, * ptr2 = NULL;
int i = 0;
int j = 0;
int k = 0;
int v1_arr[3];
int v2_arr[3];

ptr1 = strtok(v1, ".");

while (ptr1 != NULL) {
    v1_arr[i] = atoi(ptr1);
    ptr1 = strtok(NULL, ".");
    i++;
}

ptr2 = strtok(v2, ".");

while (ptr2 != NULL) {
    v2_arr[j] = atoi(ptr2);
    ptr2 = strtok(NULL, ".");
    j++;

}


while (k<3) {
    if (v1_arr[k] > v2_arr[k]) {
        printf("첫번째 버전이 더 최신입니다.\n");
        break;
    }
    else if (v1_arr[k] < v2_arr[k]) {

        printf("두번째 버전이 더 최신입니다.\n");
        break;
    }
    else {
        k++;
        continue;
    }
}

}

Python 3.11 버전입니다
a = "1.0.2"
b = "2.0.10"
a1 = a.split(".")
b1 = b.split(".")
i = 0
for i in range(0,len(a1)):
    if int(a1[i]) == int(b1[i]) :
        continue
    elif int(a1[i]) > int(b1[i]):
        print(a, ">", b)
        break
    else:
        print(b, ">", a)
        break

def version(x, y):
    X = x.split('.')
    Y = y.split('.')  
    i = 0
    while True:
        if int(X[i]) > int(Y[i]):
            print(a + ' > ' + b)
            break
        elif int(X[i]) < int(Y[i]): 
            print(a + ' < ' + b)
            break
        else:
            i += 1

a = input()
b = input()
version(a, b)

python

from functools import reduce
a,b = input("입력하시오(띄워쓰시오):").split()

A = [int(i) for i in a.split(".")]
B= [int(i) for i in b.split(".")]
A.append(0)
B.append(0)


if reduce(lambda x,y : x+y, A) == reduce(lambda x,y : x+y, B):
    print("동일 버전입니다")
else:
    for i in range(min(len(A),len(B))):
            if A[i] > B[i]:
                print("{}가 더 높은 버전입니다".format(a))
                break
            elif A[i] < B[i] :
                print("{}가 더 높은 버전입니다".format(b))
                break

str1 = input()
str2 = input()

def checkVersion(ver1,ver2):
    verList1=ver1.split('.')
    verList2=ver2.split('.')
    while(len(verList1) != len(verList2)):
        if len(verList1) > len(verList2):
            verList2.append('0')
        elif len(verList2) > len(verList1):
            verList1.append('0')#버전 자리수 맞추기

    for i in range(len(verList1)):
        if (verList1==verList2):
            print(str1,'=',str2)#1,2가 같다면 
            break
        elif verList1[i] > verList2[i]:
            print(str1,'>',str2)#1이 크다면
            break
        elif verList2[i] > verList1[i]:
            print(str1,'<',str2)#2가 크다면
            break 

checkVersion(str1,str2)

v1=input('첫 번째 프로그램 버전을 입력하시오')
v2=input('두 번째 프로그램 버전을 입력하시오')

list1=list(v1.split('.'))
list2=list(v2.split('.'))

if list1>list2:
    print('첫 번째 프로그램이 최신 버전입니다.')
else:
    print('두 번째 프로그램이 최신 버전입니다.')

v_1,v_2 = input("Enter (0.0.0,0.0.1):").split(',')
v_12 = list(map(int,v_1.split('.')))
v_22 = list(map(int,v_2.split('.')))
if v_12 != v_22:
   for i in range(min(men(v_12),len(v_22))):
      if v_12[i] > v_22[i]:
         print(v_1,'>',v_2)
         break
      elif v_12[i] < v_22[i]:
         print(v_2,'>',v_1)
         break
      else:continue
else: print(v_1,'=',v_2)

data = "1.0.23, 1.1"
data2 = data.split(",")

a = data2[0].split(".")
b = data2[1].split(".")

i = 0
while a[i] != "" or b[i] !="":
    if int(a[i]) > int(b[i]):
        print(data2[0],end = " ")
        print(">", end = " ")
        print(data2[1])
        break

    elif int(a[i]) < int(b[i]):
        print(data2[1], end = " ")
        print(">", end = " ")
        print(data2[0])
        break

    i = i+1

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

namespace 버전비교
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string[,] versions = { { "0.0.2", "0.0.1" }, { "1.0.10", "1.0.3" },
                                    { "1.2.0", "1.1.99" }, {"1.1", "1.0.1"} };
            string left = "", right = "";

            for (int i = 0; i < versions.GetLength(0); i++)
            {
                for (int j = 0; j < versions[i,0].Length; j++)
                    if (char.IsDigit(versions[i, 0][j]))
                        left += versions[i,0][j];
                for (int j = 0; j < versions[i, 1].Length; j++)
                    if (char.IsDigit(versions[i, 1][j]))
                        right += versions[i, 1][j];
                Console.WriteLine( "{0} {1} {2}", versions[i,0], 
                    comparerVersions(left,right), versions[i,1]);
            }
            Console.ReadLine();
        }

        private static string comparerVersions(string left, string right)
        {
            int len = Math.Max(left.Length, right.Length);
            left = left.PadRight(len, '0');
            right = right.PadRight(len, '0');
            for (int i = 0; i < len; i++)
            {
                int a = int.Parse(left[i].ToString());
                int b = int.Parse(right[i].ToString());
                if (a > b) return ">";
                else if (a < b) return "<";
            }            
            return "=";
        }
    }
}

version_1 = input()
version_2 = input()
a = list(map(int, version_1.split('.')))
b = list(map(int, version_2.split('.')))
li = [len(a), len(b)]
ln = min(li)
for i in range(ln):
    if a[i] > b[i]:
        print(version_1+'>'+version_2)
        quit()
    elif a[i] < b[i]:
        print(version_1+'<'+version_2)
        quit()
    else:
        pass
if len(a) > len(b):
    print(version_1+'>'+version_2)
    quit()
elif len(a) < len(b):
    print(version_1+'<'+version_2)
    quit()
else:
    print(version_1+'='+version_2)

from itertools import zip_longest
def compVer(x, y):
    for i, j in zip_longest(x.strip('.').split('.'), y.strip('.').split('.'), fillvalue='-1'):
        if int(i) > int(j): return '>'
        if int(i) < int(j): return '<'
    return '='

ex = [('0.0.2','0.0.1'), ('1.0.10','1.0.3'), ('1.2.0','1.1.99'), ('1.1','1.0.1')]
_ = [print(x, compVer(x,y), y) for x,y in ex]

> 0.0.2 > 0.0.1
> 1.0.10 > 1.0.3
> 1.2.0 > 1.1.99
> 1.1 > 1.0.1

def version(a,b):
    a_v = a.split(".")
    b_v = b.split(".")
    if a_v[0] > b_v[0] :
        return f"{a}>{b}"
    elif a_v[0] < b_v[0] :
        return f"{a}<{b}"
    else :
        if a_v[1] > b_v[1] :
            return f"{a}>{b}"
        elif a_v[1] < b_v[1] :
            return f"{a}<{b}"
        else :
            if a_v[2] > b_v[2] :
                return f"{a}>{b}"
            elif a_v[2] < b_v[2] : 
                return f"{a}<{b}"
            else :
                return f"{a}={b}"