#!/usr/bin/perl
use strict; use warnings;


  # 파일이면 OK
  if (-f "COOL") {
    print "OK! 파일입니다\n";
  }

  # 디렉토리면 OK
  if (-d "COOL") {
    print "OK! 디렉토리입니다\n";
  }

#!/usr/bin/perl
use strict; use warnings;


  # 파일 존재 여부 판단
  if (-f "test.txt") {
    print "파일 있음\n";
  }
  else {
    print STDERR "그런 파일이 없음.\n";
  }



  # 디렉토리 존재 여부 판단
  if (-d "000") {
    print "OK! 그런 디렉토리가 있음\n";
  }
  else {
    print STDERR "그런 디렉토리가 없음.\n";
  }

#!/usr/bin/perl
use strict; use warnings;

use File::Basename;


# 패스: My Jukebox 라는 디렉토리 밑의 "Cool Jazz.mp3" 라는 파일명
my ($fileNameOnly, $dir, $ext) = fileparse("My Jukebox/Cool Jazz.mp3", '\.[^.]*');


# 패스에서 디렉토리명만 구하기
print "<", $dir, ">\n";
# 출력 결과: <My Jukebox/>


# 패스에서 파일명만 구하기 (확장자 제외)
print "<", $fileNameOnly, ">\n";
# 출력 결과: <Cool Jazz>


# 패스에서 확장자만 구하기
print "<", $ext, ">\n";
# 출력 결과: <.mp3>



##########################



# 파일명만 간단히 얻기 (확장자 포함)
my $s = basename("/000/perl.pdf");
print $s, "\n";
# 출력 결과: perl.pdf


# 디렉토리명만 간단히 구하기
$s = dirname("/000/perl.pdf");
print $s, "\n";
# 출력 결과: /000


# 확장자만 별도로 구하기
$s = (fileparse("/000/perl.pdf", '\.[^.]*'))[2];
print $s, "\n";
# 출력 결과: .pdf


# 확장자 없는 파일에서 확장자를 구하면
$s = (fileparse("/000/Test", '\.[^.]*'))[2];
print "<", $s, ">\n";
# <> 이렇게 빈 문자열 출력


# 2중 확장자 파일명에서 진짜 확장자를 구하기
$s = (fileparse("Date.tar.gz", '\.[^.]*'))[2];
print "<", $s, ">\n";
# <.gz>

#!/usr/bin/perl
use strict; use warnings;

  my $filename;
  my $ext;
  my $s;



  # 파일명 정의
  $filename = "test.txt";

  # 확장자 매치 (이 경우는 txt)
  $filename =~ m<.+\.(\w+)?$>;
  # 패스명의 슬래시(/)와 충돌하기에
  # 정규식 구분자를 < 기호로 변경했음

  # 매치된 확장자가 들어간 $1 이라는 변수의 값을 꺼냄
  $ext = $1;
  print "<", $ext, ">\n";
  # 출력 결과: <txt>
  # 알아보기 쉽게 확장자를 <> 기호로 둘렀습니다.
  # 실제는 txt 만 출력됨




  # 공백 들어간 파일명
  $filename = "My Test.doc";
  $filename =~ m<.+\.(\w+)?$>;
  print "<", $1, ">\n";
  # 출력 결과: <doc>


  # 확장자 없는 파일명
  $filename = "Cool";
  $ext = "";
  $ext = $1 if ($filename =~ m<.+\.(\w+)?$>);
  print "<", $ext, ">\n";
  # 출력 결과: <>
  # 아무것도 매치되지 않았기에,
  # $1 의 값은 예전 값인 doc 을 가지고 있음
  # 따라서 if를 사용하여 구현


  # 마침표가 2개 이상인 파일명에서도
  $filename = "Oh... Hmm.Cool.xls";
  print "<", $filename =~ m<.+\.(\w+)?$>, ">\n";
  # <xls>


  # 2중 확장자는 마지막 확장자만 추출
  $filename = "Date.tar.gz";
  print "<", $filename =~ m<.+\.(\w+)?$>, ">\n";
  # <gz>


  # 유닉스/리눅스 히든 파일 (앞에 점 있는 파일)
  $filename = ".inputrc";
  print "<", $filename =~ m<.+\.(\w+)?$>, ">\n";
  # <>
  # 윈도우에서는 이 경우 inputrc 를 확장자로 간주하지만
  # 실은 확장자가 아니기에 없는 것이 정상

<script type="text/javascript">

//////////////////////////////////////////////////////////
// 전체값에서 일부값은 몇 퍼센트? 계산
// 공식은 '일부값 나누기 전체값 곱하기 100'
//////////////////////////////////////////////////////////

var result;

// 10은 100에서 몇 퍼센트?
result = 10 / 100 * 100;
document.write(result, '%<br />');
// 출력 결과: 10%


// 33은 100에서 몇 퍼센트?
var x = 33;
var y = 100;
result = x / y * 100;
document.write(result, '%<br />');
// 출력 결과: 33%


// 105는 300의 몇퍼센트?
document.write(105 / 300 * 100, '%<br />');
// 출력 결과: 35%


// 한달 봉급 156만원인 사람이, 음식 값으로 21만원을 쓰면,
// 그 음식값은 한 달 봉급의 몇 퍼센트?
document.write(210000 / 1560000 * 100, '%<br />');
// 출력 결과: 13.461538461538461%


// 만약 봉급 156만원으로 모두 먹는 데 사용했다면
// 100% 가 나와야겠지요.
document.write(1560000 / 1560000 * 100, '%<br />');
// 출력 결과: 100%


// 만약 아무것도 먹지 않았면 0% 가 나와야합니다.
document.write(0 / 1560000 * 100, '%<br />');
// 출력 결과: 0%





//////////////////////////////////////////////////////////
// 전체값의 몇 퍼센트는 얼마? 계산
// 공식은, '전체값 곱하기 퍼센트 나누기 100'
//////////////////////////////////////////////////////////


// 100의 10퍼센트는 얼마?
document.write(100 * 10 / 100, '<br />');
// 출력 결과: 10


// 100의 33퍼센트는 얼마?
document.write(100 * 33 / 100, '<br />');
// 출력 결과: 33


// 300의 35퍼센트는 얼마?
document.write(300 * 35 / 100, '<br />');
// 출력 결과: 105


// 156만원의 13.461538461538461퍼센트는 얼마?
document.write(1560000 * 13.461538461538461 / 100, '<br />');
// 출력 결과: 210000


// 156만원의 100퍼센트는 얼마?
document.write(1560000 * 100 / 100, '<br />');
// 출력 결과: 1560000


// 156만원의 0퍼센트는 얼마?
document.write(1560000 * 0 / 100, '<br />');
// 출력 결과: 0

</script>

#!/usr/bin/perl
use strict; use warnings;

# 소수를 분수로 변환 (약분하여 출력)

print printFraction(decimalToFraction(0.5)), "\n"; # 1/2
print printFraction(decimalToFraction(0.1)), "\n"; # 1/10
print printFraction(decimalToFraction(1.1)), "\n"; # 11/10
print printFraction(decimalToFraction(3.44)), "\n"; # 86/25
print printFraction(decimalToFraction(3)), "\n"; # 3/1
print printFraction(decimalToFraction(0)), "\n"; # 0/1
print printFraction(decimalToFraction(5.4877325)), "\n"; # 1371933/250000
print printFraction(decimalToFraction(26.1245)), "\n"; # 52249/2000
print printFraction(decimalToFraction(2545.139)), "\n"; # 2545139/1000
print printFraction(decimalToFraction(0.25)), "\n"; # 1/4
print printFraction(decimalToFraction(0.42857142)), "\n"; # 428571/1000000 (=3/7)
print printFraction(decimalToFraction(0.3333333)), "\n"; # 333333/1000000
print printFraction(decimalToFraction(0.000071)), "\n"; # 71/1000000

# 파이값(원주율)을 분수로 변환
print printFraction(decimalToFraction(3.1415926535897932384626433832795)), "\n";
# 3141593/1000000




# 소수를 분수로 변환 함수
sub decimalToFraction {
  my $iP = int($_[0]);          # 소수의 정수부만 구하기
  my $fP = $_[0] - int($_[0]);  # 소수의 소수부만 구하기

  $fP = RoundXL($fP, 6);        # 소수부의 정밀도가 지나치게 높지 않게끔 반올림
  my $bunmo = 10 ** (length($fP) - 2); # 소수점 이하 자릿수만큼 분모 만들기: 가령 0.001 은 1000 으로

  return reduceFraction(($iP + $fP) * $bunmo, $bunmo); # 약분 후, 분자, 분모 반환
}


# 분수를 알아보기 쉽게 출력하는 함수
# 분수의 구성 요소가 든 배열을 분수로 출력
sub printFraction {
  return $_[0], "/", $_[1];
}


# 분수 약분 함수 (Reduce a Fraction)
# 분자 분모를 입력받아, 약분 후, 분자 분모가 든 배열을 반환
sub reduceFraction {
  my @frac = @_;
  if ($frac[1] == 0) { return "NaN", "NaN"; } # 분모가 0일 경우에 에러 반환

  my $gcd = gcd(@frac);

  return ($frac[0] / $gcd, $frac[1] / $gcd);
}


# 최대 공약수 계산 함수
sub gcd {
  my $a = $_[0];
  my $b = $_[1];

  while ($b != 0) {
    my $temp = $a % $b;
    $a = $b;
    $b = $temp;
  }

  return abs($a);
}


# 실수를 실수로, 지정한 자릿수에서 반올림 함수
sub RoundXL {
  sprintf("%.$_[1]f", $_[0]);
}

<script type="text/javascript">
// 0.0에서 1.0까지의 난수 1개 출력

var result = Math.random();
document.write(result);

</script>




<br /><br /><br /> <!-- 줄바꿈 -->




<script type="text/javascript">
// 0.0에서 1.0까지의 난수 30개 출력

for (var i = 0; i <= 30; i++)
  document.write(Math.random(), '<br />');

</script>

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


  //////////////////////////////////////////////////////////
  // 전체값에서 일부값은 몇 퍼센트? 계산
  // 공식은 "일부값 나누기 전체값 곱하기 100"
  //////////////////////////////////////////////////////////


  // 10은 100에서 몇 퍼센트?
  System.out.format("%.2f%%%n", 10.0 / 100.0 * 100.0);
  // 출력 결과: 10.00%


  // 33은 100에서 몇 퍼센트?
  int x = 33;
  int y = 100;
  System.out.println( (double) x / (double) y * 100.0 + "%");
  // 출력 결과: 33.0%
  // 정수의 경우에는 (double) 로 실수화시키지 않으면
  // 0.0 이라는 엉뚱한 값이 나옴
  // 맨 끝의 + "%" 이 부분은 공식의 일부가 아니라 퍼센트 기호 출력


  // 105는 300의 몇퍼센트?
  double x2 = 105.0;
  double y2 = 300.0;
  System.out.format("%.2f%%%n", x2 / y2 * 100.0);
  // 출력 결과: 35.00%
  // 실수형 변수에 값을 넣어두는 것이 좋음


  // 한달 봉급 156만원인 사람이, 음식 값으로 21만원을 쓰면,
  // 그 음식값은 한 달 봉급의 몇 퍼센트?
  System.out.format("%.2f%%%n", 210000.0 / 1560000.0 * 100.0);
  // 출력 결과: 13.46%


  // 만약 봉급 156만원으로 모두 먹는 데 사용했다면
  // 100% 가 나와야겠지요.
  System.out.format("%.2f%%%n", 1560000.0 / 1560000.0 * 100.0);
  // 출력 결과: 100.00%


  // 만약 아무것도 먹지 않았면 0% 가 나와야합니다.
  System.out.format("%.2f%%%n", 0.0 / 1560000.0 * 100.0);
  // 출력 결과: 0.00%





  //////////////////////////////////////////////////////////
  // 전체값의 몇 퍼센트는 얼마? 계산
  // 공식은, "전체값 곱하기 퍼센트 나누기 100"
  //////////////////////////////////////////////////////////


  // 100의 10퍼센트는 얼마?
  System.out.format("%.2f%n", 100.0 * 10.0 / 100.0);
  // 출력 결과: 10.00


  // 100의 33퍼센트는 얼마?
  System.out.format("%.2f%n", 100.0 * 33.0 / 100.0);
  // 출력 결과: 33.00


  // 300의 35퍼센트는 얼마?
  System.out.format("%.2f%n", 300.0 * 35.0 / 100.0);
  // 출력 결과: 105.00


  // 156만원의 13.46퍼센트는 얼마?
  System.out.format("%.2f%n", 1560000.0 * 13.46 / 100.0);
  // 출력 결과 (21만원에 가까운 값): 209976.00


  // 156만원의 100퍼센트는 얼마?
  System.out.format("%.2f%n", 1560000.0 * 100.0 / 100.0);
  // 출력 결과: 1560000.00


  // 156만원의 0퍼센트는 얼마?
  System.out.format("%.2f%n", 1560000.0 * 0.0 / 100.0);
  // 출력 결과: 0.00


  }
}

#!/usr/bin/perl
use strict; use warnings;

  my $result;

  $result = 10 % 5;
  print $result, "\n";
  # 출력 결과: 0
  # 10을 5로 나누면, 딱 떨어지고 나머지는 없기에 0(영)입니다.


  print 10 % 2, "\n";
  # 출력 결과: 0
  # 10을 2로 나누어도 나머지는 0입니다.


  $result = 13 % 5;
  printf("나머지: %d\n", $result);
  # 출력 결과: 3
  # 13을 5로 나누면 나머지는 3


  printf("나머지: %d\n", 13 % 2);
  # 출력 결과: 1

#!/usr/bin/perl
use strict; use warnings;


  ###############################################
  # 전체값에서 일부값은 몇 퍼센트? 계산
  # 공식은 "일부값 나누기 전체값 곱하기 100"
  ###############################################


  # 10은 100에서 몇 퍼센트?
  printf("%.2f%%\n", 10 / 100 * 100);
  # 출력 결과: 10.00%


  # 33은 100에서 몇 퍼센트?
  printf("%.2f%%\n", 33 / 100 * 100);
  # 출력 결과: 33.00%


  # 105는 300의 몇퍼센트?
  printf("%.2f%%\n", 105 / 300 * 100);
  # 출력 결과: 35.00%


  # 한달 봉급 156만원인 사람이, 음식 값으로 21만원을 쓰면,
  # 그 음식값은 한 달 봉급의 몇 퍼센트?
  printf("%.2f%%\n", 210000 / 1560000 * 100);
  # 출력 결과: 13.46%


  # 만약 봉급 156만원으로 모두 먹는 데 사용했다면
  # 100% 가 나와야겠지요.
  printf("%.2f%%\n", 1560000 / 1560000 * 100);
  # 출력 결과: 100.00%


  # 만약 아무것도 먹지 않았면 0% 가 나와야합니다.
  printf("%.2f%%\n", 0 / 1560000 * 100);
  # 출력 결과: 0.00%





  ###############################################
  # 전체값의 몇 퍼센트는 얼마? 계산
  # 공식은, "전체값 곱하기 퍼센트 나누기 100"
  ###############################################


  # 100의 10퍼센트는 얼마?
  printf("%.2f\n", 100 * 10 / 100);
  # 출력 결과: 10.00


  # 100의 33퍼센트는 얼마?
  printf("%.2f\n", 100 * 33 / 100);
  # 출력 결과: 33.00


  # 300의 35퍼센트는 얼마?
  printf("%.2f\n", 300 * 35 / 100);
  # 출력 결과: 105.00


  # 156만원의 13.46퍼센트는 얼마?
  printf("%.2f\n", 1560000 * 13.46 / 100);
  # 출력 결과 (21만원에 가까운 값): 209976.00


  # 156만원의 100퍼센트는 얼마?
  printf("%.2f\n", 1560000 * 100 / 100);
  # 출력 결과: 1560000.00


  # 156만원의 0퍼센트는 얼마?
  printf("%.2f\n", 1560000 * 0 / 100);
  # 출력 결과: 0.00

#include <stdio.h>

int main(void) {

  // 정수 나눗셈의 정확한 결과를 구하려면
  // 정수를 (double) 로 캐스팅하여 실수로 만들어 주어야 함
  int x = 100;
  int y = 3;

  printf("%f\n", (double) x / (double) y);
  // 출력 결과: 33.333333




  // 더 좋은 방법은, 처음부터
  // 변수를 실수형(double)으로 선언하고
  // 상수도 100.0 이렇게 끝에 ".0"을 붙여 실수화하는 것입니다.
  double x2 = 100.0;
  double y2 = 3.0;

  printf("%f\n", x2 / y2);
  // 출력 결과: 33.333333


  return 0;
}

import java.io.*;
import java.util.*;

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

    Calendar cal = Calendar.getInstance();
    String dateString;

    dateString = String.format("%04d-%02d-%02d", cal.get(Calendar.YEAR), cal.get(Calendar.MONTH) + 1, cal.get(Calendar.DAY_OF_MONTH));

    File f = new File(dateString);
    if (!f.mkdirs())
      System.err.println("디렉토리 생성 실패");


  }
}

import java.util.Calendar;

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

    Calendar cal = Calendar.getInstance();
    String dateString, timeString;

    dateString = String.format("%04d-%02d-%02d", cal.get(Calendar.YEAR), cal.get(Calendar.MONTH) + 1, cal.get(Calendar.DAY_OF_MONTH));
    timeString = String.format("%02d:%02d:%02d", cal.get(Calendar.HOUR_OF_DAY), cal.get(Calendar.MINUTE), cal.get(Calendar.SECOND));

    System.out.println(dateString + " " + timeString);

  }
}

#include <iostream>

using namespace std;


int main(void) {
  int bar = 123;
  const int FOO = 999;

  bar++;
  cout << bar << endl;

  cout << FOO << endl;


  return 0;
}

#include <stdio.h>
#include <math.h>

void printFraction(int* bunsu);
int* reduceFraction(int bunja, int bunmo);
int gcd(int a, int b);



int main(void) {

  // 5/10 (10분의 5)
  printFraction(reduceFraction(5, 10));
  // 출력 결과: 1/2

  // 1/2 (2분의 1)
  printFraction(reduceFraction(1, 2));
  // 출력 결과: 1/2

  // 2940/3150 (3150분의 2940)
  printFraction(reduceFraction(2940, 3150));
  // 출력 결과: 14/15

  // 6/63 (63분의 6)
  printFraction(reduceFraction(6, 63));
  // 출력 결과: 2/21

  // 63/6 (6분의 63)
  printFraction(reduceFraction(63, 6));
  // 출력 결과: 21/2

  // 1/1 (1분의 1)
  printFraction(reduceFraction(1, 1));
  // 출력 결과: 1/1

  // 555/555 (555분의 555)
  printFraction(reduceFraction(555, 555));
  // 출력 결과: 1/1

  // 0/1 (1분의 0)
  printFraction(reduceFraction(0, 1));
  // 출력 결과: 0/1

  // 1/0 (0분의 1)
  printFraction(reduceFraction(1, 0));
  // 출력 결과 (에러): 0/0
  // 분모가 0이 될 수는 없음

  // 0/0 (0분의 0)
  printFraction(reduceFraction(0, 0));
  // 출력 결과 (에러): 0/0



  return 0;
}




// 분수 출력 함수
// (분자 분모가 든 배열을 입력받아 출력)
void printFraction(int* bunsu) {
  printf("%d/%d\n", bunsu[0], bunsu[1]);
}




// 분수 약분 함수 (Reduce a Fraction)
// 분자 분모를 입력받아, 약분 후, 분자 분모가 든 배열을 반환
int* reduceFraction(int bunja, int bunmo) {
  static int frac[2];
  frac[0] = bunja;
  frac[1] = bunmo;

  if (frac[1] == 0) { // 분모가 0일 경우에 에러 반환
    frac[0] = NULL;
    frac[1] = NULL;

    return frac;
  }

  // 함수와 변수명을 모두 gcd 로 하면 "error C2064: term does not evaluate to a function taking 2 arguments" 이러 에러 발생함
  int gcd_result = gcd(frac[0], frac[1]);

  frac[0] = frac[0] / gcd_result;
  frac[1] = frac[1] / gcd_result;

  return frac;
}


// 최대 공약수 계산 함수
// (Euclidean Algorithm; Euclid's Algorithm)
int gcd(int a, int b) {

  while (b != 0) {
    int temp = a % b;
    a = b;
    b = temp;
  }

  return abs(a);
}

지금은 저 <span style="font-size:24pt; line-height:1.5em">뜬구름</span>조차도 영속적인 존재로 보이고 있다.

지금은 저 <span id="mytest">뜬구름</span>조차도 영속적인 존재로 보이고 있다.

<!-- 강조한다는 의미의 이탤릭체는 em 태그 사용이 좋습니다 -->
The <em>quick brown fox jumps over</em> the lazy dog.<br />
지금은 어쩐지 저 <em>뜬구름조차도</em> 영속적인 존재로 보이고 있다.<br /><br />


<!-- 인용한다는 의미의 이탤릭체는 cite 태그 사용이 좋습니다 -->
The <cite>quick brown fox jumps over</cite> the lazy dog.<br />
지금은 어쩐지 저 <cite>뜬구름조차도</cite> 영속적인 존재로 보이고 있다.<br /><br />


<!-- 또는 CSS스타일 시트를 직접 지정할 수도 있습니다 -->
The <span style="font-style:italic">quick brown fox jumps over</span> the lazy dog.<br />
지금은 어쩐지 저 <span style="font-style:italic">뜬구름조차도</span> 영속적인 존재로 보이고 있다.<br /><br />


<!-- i (아이) 태그는 최신 웹표준에 맞지 않습니다 -->
The <i>quick brown fox jumps over</i> the lazy dog.<br />
지금은 어쩐지 저 <i>뜬구름조차도</i> 영속적인 존재로 보이고 있다.<br /><br />

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

    // 5/10 (10분의 5)
    printFraction(reduceFraction(5, 10));
    // 출력 결과: 1/2

    // 1/2 (2분의 1)
    printFraction(reduceFraction(1, 2));
    // 출력 결과: 1/2

    // 2940/3150 (3150분의 2940)
    printFraction(reduceFraction(2940, 3150));
    // 출력 결과: 14/15

    // 6/63 (63분의 6)
    printFraction(reduceFraction(6, 63));
    // 출력 결과: 2/21

    // 63/6 (6분의 63)
    printFraction(reduceFraction(63, 6));
    // 출력 결과: 21/2

    // 1/1 (1분의 1)
    printFraction(reduceFraction(1, 1));
    // 출력 결과: 1/1

    // 555/555 (555분의 555)
    printFraction(reduceFraction(555, 555));
    // 출력 결과: 1/1

    // 0/1 (1분의 0)
    printFraction(reduceFraction(0, 1));
    // 출력 결과: 0/1

    // 1/0 (0분의 1)
    printFraction(reduceFraction(1, 0));
    // 출력 결과 (에러): 0/0
    // 분모가 0이 될 수는 없음

    // 0/0 (0분의 0)
    printFraction(reduceFraction(0, 0));
    // 출력 결과 (에러): 0/0

  }




  // 분수 출력 함수
  // (분자 분모가 든 배열을 입력받아 출력)
  public static void printFraction(int[] bunsu) {
    System.out.format("%d/%d%n", bunsu[0], bunsu[1]);
  }




  // 분수 약분 함수 (Reduce a Fraction)
  // 분자 분모를 입력받아, 약분 후, 분자 분모가 든 배열을 반환
  public static int[] reduceFraction(int bunja, int bunmo) {
    int[] frac = new int[2];
    frac[0] = bunja;
    frac[1] = bunmo;

    if (frac[1] == 0) { // 분모가 0일 경우에 에러 반환
      frac[0] = 0;
      frac[1] = 0;
      return frac;
    }

    int gcd_result = gcd(frac[0], frac[1]);

    frac[0] = frac[0] / gcd_result;
    frac[1] = frac[1] / gcd_result;

    return frac;
  }




  // 최대 공약수 계산 메서드
  // (Euclidean Algorithm; Euclid's Algorithm)
  public static int gcd(int a, int b) {

    while (b != 0) {
      int temp = a % b;
      a = b;
      b = temp;
    }

    return Math.abs(a);
  }


}

#!/usr/bin/python
# -*- coding: cp949 -*-

# 분수 출력 함수
# (분자 분모가 든 리스트 입력받아 출력)
def printFraction(bunsu):
  print "%d/%d" % (bunsu[0], bunsu[1])




# 최대 공약수 계산 메서드
# (Euclidean Algorithm; Euclid's Algorithm)
def gcd(a, b):
  while (b != 0):
    temp = a % b
    a = b
    b = temp
  return abs(a)




# 분수 약분 함수 (Reduce a Fraction)
# 분자 분모를 입력받아, 약분 후, 분자 분모가 든 배열을 반환
def reduceFraction(bunja, bunmo):
  frac = [ bunja, bunmo ]

  if (frac[1] == 0): # 분모가 0일 경우에 에러 반환
    frac[0] = 0
    frac[1] = 0
    return frac

  gcd_result = gcd(frac[0], frac[1])

  frac[0] = frac[0] / gcd_result
  frac[1] = frac[1] / gcd_result

  return frac



########## 여기 이하부터는 약분 테스트 ###########


# 5/10 (10분의 5)
printFraction(reduceFraction(5, 10));
# 출력 결과: 1/2

# 1/2 (2분의 1)
printFraction(reduceFraction(1, 2));
# 출력 결과: 1/2

# 2940/3150 (3150분의 2940)
printFraction(reduceFraction(2940, 3150));
# 출력 결과: 14/15

# 6/63 (63분의 6)
printFraction(reduceFraction(6, 63));
# 출력 결과: 2/21

# 63/6 (6분의 63)
printFraction(reduceFraction(63, 6));
# 출력 결과: 21/2

# 1/1 (1분의 1)
printFraction(reduceFraction(1, 1));
# 출력 결과: 1/1

# 555/555 (555분의 555)
printFraction(reduceFraction(555, 555));
# 출력 결과: 1/1

# 0/1 (1분의 0)
printFraction(reduceFraction(0, 1));
# 출력 결과: 0/1

# 1/0 (0분의 1)
printFraction(reduceFraction(1, 0));
# 출력 결과 (에러): 0/0
# 분모가 0이 될 수는 없음

# 0/0 (0분의 0)
printFraction(reduceFraction(0, 0));
# 출력 결과 (에러): 0/0

#!/usr/bin/perl
use strict; use warnings;

  # 5/10 (10분의 5)
  printFraction(reduceFraction(5, 10));
  # 출력 결과: 1/2

  # 1/2 (2분의 1)
  printFraction(reduceFraction(1, 2));
  # 출력 결과: 1/2

  # 2940/3150 (3150분의 2940)
  printFraction(reduceFraction(2940, 3150));
  # 출력 결과: 14/15

  # 6/63 (63분의 6)
  printFraction(reduceFraction(6, 63));
  # 출력 결과: 2/21

  # 63/6 (6분의 63)
  printFraction(reduceFraction(63, 6));
  # 출력 결과: 21/2

  # 1/1 (1분의 1)
  printFraction(reduceFraction(1, 1));
  # 출력 결과: 1/1

  # 555/555 (555분의 555)
  printFraction(reduceFraction(555, 555));
  # 출력 결과: 1/1

  # 0/1 (1분의 0)
  printFraction(reduceFraction(0, 1));
  # 출력 결과: 0/1

  # 1/0 (0분의 1)
  printFraction(reduceFraction(1, 0));
  # 출력 결과 (에러): NaN/NaN

  # 0/0 (0분의 0)
  printFraction(reduceFraction(0, 0));
  # 출력 결과 (에러): NaN/NaN




# 분수 출력 함수
# (분자 분모가 든 배열을 입력받아 출력)
sub printFraction {
  print $_[0], "/", $_[1], "\n";
}


# 분수 약분 함수 (Reduce a Fraction)
# 분자 분모를 입력받아, 약분 후, 분자 분모가 든 배열을 반환
sub reduceFraction {
  my @frac = @_;
  if ($frac[1] == 0) { return "NaN", "NaN"; } # 분모가 0일 경우에 에러 반환

  my $gcd = gcd(@frac);

  return ($frac[0] / $gcd, $frac[1] / $gcd);
}


# 최대 공약수 계산 함수
sub gcd {
  my $a = $_[0];
  my $b = $_[1];

  while ($b != 0) {
    my $temp = $a % $b;
    $a = $b;
    $b = $temp;
  }

  return abs($a);
}

#!/usr/bin/perl
use strict; use warnings;

  print gcd(12, 18), "\n";
  # 6

  print gcd(5154, 3435), "\n";
  # 3

  print gcd(0, 0), "\n";
  # 0
  # 이 경우는 0으로 정의되어 있음

  print gcd(1, 0), "\n";
  # 1
  # 이것도 맞습니다.

  print gcd(0, 12), "\n";
  # 12
  # 이것도 맞습니다.

  print gcd(13, 12), "\n";
  # 1
  # 공약수가 1밖에 없는 '서로소(Relatively Prime; Coprime)'

  print gcd(-42, -56), "\n";
  # 14
  # 최대공약수는 항상 양수임

  # 세 가지 수의 최대공약수 구하기
  print gcd(gcd(42, 12), 48), "\n";
  # 6





# 최대 공약수 계산 함수
sub gcd {
  my $a = $_[0];
  my $b = $_[1];

  while ($b != 0) {
    my $temp = $a % $b;
    $a = $b;
    $b = $temp;
  }

  return abs($a);
}

#include <stdio.h>

int main(void) {

  // 끝의 "+ 1" 은 null 문자 1개의 길이
  // 실제는 총50바이트의 문자열
  char s[50 + 1];

  printf("아무 문자열이나 입력하세요: ");
  fgets(s, sizeof(s), stdin);
  printf("방금 입력받은 문자열: %s\n", s);


  return 0;
}

#include <stdio.h>
#include <string.h> // strlen()

int main(void) {

  // 끝의 개행문자 2개의 공간 포함
  // 실제는 총50바이트의 문자열
  char s[50 + 2];

  printf("아무 문자열이나 입력하세요: ");
  fgets(s, sizeof(s), stdin);

  // fgets 는 개행문자를 붙이기에
  // 개행문자를 제거해야 함
  s[strlen(s)-1] = '\0';

  printf("방금 입력받은 문자열: <%s>\n", s);


  return 0;
}

#include <stdio.h>

int main(void) {

  // 200바이트의 문자열이 저장되는 배열
  // 배열의 끝을 알리는 NULL 문자 1개의 공간이 필요하기에 200 + 1 = 201
  char s[201];

  int i;
  double d;




/* 문자열 입력받기 */
  printf("\n\n아무 문자열이나 200바이트까지 입력: ");
  // "%s" 이렇게 문자열 길이를 지정 않으면 보안에 취약하므로 "%200s" 이렇게 길이 지정.
  // 또는 안전한 버전인 scanf_s() 를 대신 사용하면 됨.
  scanf("%200s", s);
  fflush(stdin);  // 입력 버퍼 청소

  printf("OK: %s\n", s);



/* 정수 입력 */
  printf("아무 정수 입력: ");
  // i 가 아닌, &i 이렇게,
  // 변수의 포인터를 파라미터로 입력해야 합니다.
  scanf("%d", &i);
  fflush(stdin);

  printf("OK: %d\n", i);




/* 실수 입력 */
  printf("아무 실수나 입력: ");
  scanf("%lf", &d); // "%f"가 아닌 "%lf"라고 해야 함
  fflush(stdin);

  printf("OK: %f\n", d);


  return 0;
}

import java.util.*;

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

    Scanner sc = new Scanner(System.in);
    int i;


    ///////////////////////////////////////////////
    // 10진수 정수만 입력 받기

    System.out.print("정수를 입력하세요: ");


    // 정수를 올바르게 입력하면 hasNextInt() 가 true/참을 반환하기에
    // while 루프가 실행되지 않음
    while (!sc.hasNextInt()) {
      sc.next(); // 에러일 경우, 방금 입력받은 값 무시
      System.err.print("에러! 올바른 정수를 다시 입력바랍니다: ");
    }


    i = sc.nextInt();
    System.out.println("OK, 입력된 정수: " + i);





    ///////////////////////////////////////////////
    // 16진수(HEX) 정수만 입력 받기, "0x"는 없어야 함

    System.out.print("16진수를 입력하세요: ");

    while (!sc.hasNextInt(16)) {
      sc.next();
      System.err.print("에러! 다시 입력바랍니다: ");
    }

    System.out.format("OK, 입력된 16진수: %X%n", sc.nextInt(16));


  }
}

import java.util.*;

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

    Scanner sc = new Scanner(System.in);
    System.out.print("실수를 입력하세요, 정수도 가능: ");


    // 제대로 된 숫자를 입력하지 않은 경우
    // 되풀이하여 입력받기
    while (!sc.hasNextDouble()) {
      sc.next(); // 잘못된 입력 값 버리기
      System.err.print("에러! 다시 입력바랍니다: ");
    }


    // 입력받은 숫자를 변수에 저장
    double d = sc.nextDouble();
    System.out.println("OK, 입력된 실수: " + d);


  }
}

#include <stdio.h>


int main(void) {


  double d = 123.445;
  printf("%f\n", d);


  float f = 25.3f;
  printf("%f\n", f);


  int i = -10;
  printf("%d\n", i);


  unsigned int ui = 365;
  printf("%u\n", ui);



  return 0;
}