이번에는 함수의 가장 기본적인 모양을 만들고 사용해보겠습니다. 참고로 다음 코드의 Show() 메서드는 Main() 메서드 밑에 코드를 작성해도 상관 없습니다.

코드: FunctionDemo.cs

// FunctionDemo.cs
using System;

class FunctionDemo
{
    //[1] Show 메서드(함수)
    static void Show()
    {
        Console.WriteLine("Hello World");
    }

    // Main 메서드(함수)
    static void Main()
    {
        Show(); //[2] 호출
    }
}

Hello World

위 코드는 [1]번 코드 영역에 Show() 이름의 함수를 만들고 이를 Main() 메서드의 [2]번에서 호출해 보는 내용입니다. Show() 함수와 같은 형태를 가장 간단한 형태의 함수로 매개 변수(Parameter)도 없고 반환값(Return Value)도 없는 형태입니다. 잠시 후에 매개 변수와 반환값에 대해 알아봅니다.

이번에는 함수의 가장 기본적인 모양을 만들고 사용해보겠습니다. 참고로 다음 코드의 show() 메서드는 main() 메서드 아래 또는 위에 어디든 코드를 작성해도 상관 없습니다.

코드: FunctionDemo.java

public class FunctionDemo {
    // main 메서드(함수)
    public static void main(String[] args) {
        show(); // 호출
        show(); 
    }

    // show 메서드(함수)
    public static void show() {
        System.out.println("안녕하세요.");
    }
}

안녕하세요.
안녕하세요.

위 코드는 show() 이름의 함수를 만들고 이를 main() 메서드에서 두 번 호출해 보는 내용입니다. show() 함수와 같은 형태를 가장 간단한 형태의 함수로 매개 변수(Parameter)도 없고 반환값(Return Value)도 없는 형태입니다. 잠시 후에 매개 변수와 반환값에 대해 알아봅니다.

https://youtu.be/wQWfE9Cr2Y4

이번에는 함수의 가장 기본적인 모양을 만들고 사용해보겠습니다.

코드: function_demo.js

// function_demo.js

// [1] show 함수
function show() {
    console.log("Hello World");
}

// main 함수
function main() {
    show(); // [2] 호출
}

main();

Hello World

위 코드는 [1]번 코드 영역에 show() 이름의 함수를 만들고 이를 main() 함수의 [2]번에서 호출해 보는 내용입니다. show() 함수와 같은 형태는 가장 간단한 형태의 함수로 매개 변수(Parameter)도 없고 반환값(Return Value)도 없는 형태입니다. 잠시 후에 매개 변수와 반환값에 대해 알아봅니다.

코드: FunctionDemo.py

// FunctionDemo.py
>>> # FunctionDemo.py
... # 함수: 반복해서 사용하도록 만들어진 하나 이상의 문을 포함하는 코드 단위(블록)
... # 내장 함수(Function) 사용 
... print("안녕")
안녕
>>> print("안녕")
안녕
>>> print("안녕")
안녕
>>> # 사용자 정의 함수 만들기(선언, 정의)
... def hi(): 
...     print("안녕하세요.")
... 
... # 사용자 정의 함수 사용하기(호출)
>>> hi()
안녕하세요.
>>> hi()
안녕하세요.
>>> hi()
안녕하세요.

이번에는 함수의 가장 기본적인 모양을 만들고 사용해보겠습니다. 참고로 다음 코드의 show() 함수는 반드시 main 함수 앞에 코드를 작성하세요.

코드: function_demo.c

// function_demo.c
#include <stdio.h>

//[1] show 함수 선언
void show(void)
{
    printf("Hello World\n");
}

//[!] main 함수
int main(void)
{
    show(); //[2] show 함수 호출

    return 0; 
}

Hello World

위 코드는 [1]번 코드 영역에 show 이름의 함수를 만들고 이를 main 함수의 [2]번에서 호출해 보는 내용입니다. show 함수와 같은 형태를 가장 간단한 형태의 함수로 매개 변수(Parameter)도 없고 반환값(Return Value)도 없는 형태입니다. 잠시 후에 매개 변수와 반환값에 대해 알아봅니다.

이번에는 함수의 가장 기본적인 모양을 만들고 사용해보겠습니다. 참고로 다음 코드의 Show() 함수는 main() 함수 밑에 코드를 작성해도 상관 없습니다.

코드: FunctionDemo.cpp

// FunctionDemo.cpp
#include <iostream>

class FunctionDemo
{
public:
    //[1] Show 메서드(함수)
    static void Show()
    {
        std::cout << "Hello World" << std::endl;
    }
};

// main 메서드(함수)
int main()
{
    FunctionDemo::Show(); //[2] 호출
}

Hello World

위 코드는 [1]번 코드 영역에 Show() 이름의 함수를 만들고 이를 main() 메서드의 [2]번에서 호출해 보는 내용입니다. Show() 함수와 같은 형태를 가장 간단한 형태의 함수로 매개 변수(Parameter)도 없고 반환값(Return Value)도 없는 형태입니다. 잠시 후에 매개 변수와 반환값에 대해 알아봅니다.

이번에는 함수의 가장 기본적인 모양을 만들고 사용해보겠습니다.

코드: function_demo.rs

// function_demo.rs

// [1] show 함수
fn show() {
    println!("Hello World");
}

// main 함수
fn main() {
    show(); // [2] 호출
}

Hello World

위 코드는 [1]번 코드 영역에 show() 이름의 함수를 만들고 이를 main() 함수의 [2]번에서 호출해 보는 내용입니다. show() 함수와 같은 형태는 가장 간단한 형태의 함수로 매개 변수(Parameter)도 없고 반환값(Return Value)도 없는 형태입니다. 잠시 후에 매개 변수와 반환값에 대해 알아봅니다.

이번에는 매개 변수(Parameter)가 있는 함수를 만들고 사용해보겠습니다.

코드: FunctionParameter.cs

// 매개 변수(Parameter)가 있는 함수 만들고 호출하기 
using System;

class FunctionParameter
{
    // 매개 변수가 있는 함수
    static void ShowMessage(string message)
    {
        Console.WriteLine(message); // 넘어온 매개 변수의 값을 출력
    }

    static void Main()
    {
        ShowMessage("매개 변수"); // ShowMessage() 함수에 "매개 변수" 문자열 전달
        ShowMessage("Parameter"); // ShowMessage() 함수에 "Parameter" 문자열 전달
    }
}

매개 변수
Parameter

함수의 괄호 안에는 매개 변수를 선언할 수 있는데, ShowMessage(string message) 형태로 함수 호출시 문자열을 받아서 message 변수에 저장합니다. 함수를 호출할 때 동일한 데이터 형식을 전달해야 합니다. 함수의 매개 변수는 콤마 기호를 구분으로 하나 이상을 줄 수 있습니다.

이번에는 매개 변수(Parameter)가 있는 함수를 만들고 사용해보겠습니다.

코드: function_parameter.c

#include <stdio.h>

// 매개 변수가 있는 함수
void showMessage(char message[])
{
    printf("%s\n", message);
}

int main()
{
    showMessage("매개 변수"); // showMessage 함수에 "매개 변수" 문자열 전달
    showMessage("Parameter"); // showMessage 함수에 "Parameter" 문자열 전달
    return 0;
}

매개 변수
Parameter

함수의 괄호 안에는 매개 변수를 선언할 수 있는데, showMessage 함수는 char 형식의 message 매개 변수를 선언합니다. 함수를 호출할 때 매개 변수는 데이터 형식에 맞게 전달해야 합니다. C 언어에서는 문자열을 배열 형태로 다루기 때문에 문자열 매개 변수를 배열 형태로 선언합니다.

이번에는 매개 변수(Parameter)가 있는 함수를 만들고 사용해보겠습니다.

코드: FunctionParameter.java

// 매개 변수(Parameter)가 있는 함수 만들고 호출하기 
public class FunctionParameter {
    // 매개 변수가 있는 함수
    public static void showMessage(String message) {
        System.out.println(message); // 넘어온 매개 변수의 값을 출력
    }

    public static void main(String[] args) {
        showMessage("매개 변수"); // showMessage() 함수에 "매개 변수" 문자열 전달
        showMessage("Parameter"); // showMessage() 함수에 "Parameter" 문자열 전달
    }
}

매개 변수
Parameter

함수의 괄호 안에는 매개 변수를 선언할 수 있는데, showMessage(String message) 형태로 함수 호출 시 문자열을 받아서 message 변수에 저장합니다. 함수를 호출할 때 동일한 데이터 형식을 전달해야 합니다. 함수의 매개 변수는 콤마 기호를 구분으로 하나 이상을 줄 수 있습니다.

이번에는 매개 변수(Parameter)가 있는 함수를 만들고 사용해보겠습니다.

코드: function_parameter.py

# 매개 변수(Parameter)가 있는 함수 만들고 호출하기

def show_message(message):
    print(message) # 넘어온 매개 변수의 값을 출력

show_message("매개 변수") # show_message() 함수에 "매개 변수" 문자열 전달
show_message("Parameter") # show_message() 함수에 "Parameter" 문자열 전달

매개 변수
Parameter

함수의 괄호 안에는 매개 변수를 선언할 수 있는데, show_message(message) 형태로 함수 호출시 문자열을 받아서 message 변수에 저장합니다. 함수를 호출할 때 동일한 데이터 형식을 전달해야 합니다. 함수의 매개 변수는 콤마 기호를 구분으로 하나 이상을 줄 수 있습니다.

이번에는 매개 변수(Parameter)가 있는 함수를 만들고 사용해보겠습니다.

코드: function_parameter.js

// 매개 변수(Parameter)가 있는 함수 만들고 호출하기

function showMessage(message) {
    console.log(message); // 넘어온 매개 변수의 값을 출력
}

showMessage("매개 변수"); // showMessage() 함수에 "매개 변수" 문자열 전달
showMessage("Parameter"); // showMessage() 함수에 "Parameter" 문자열 전달

매개 변수
Parameter

함수의 괄호 안에는 매개 변수를 선언할 수 있는데, showMessage(message) 형태로 함수 호출시 문자열을 받아서 message 변수에 저장합니다. 함수를 호출할 때 동일한 데이터 형식을 전달해야 합니다. 함수의 매개 변수는 콤마 기호를 구분으로 하나 이상을 줄 수 있습니다.

이번에는 매개 변수(Parameter)가 있는 함수를 만들고 사용해보겠습니다.

코드: function_parameter.cpp

#include <iostream>
using namespace std;

// 매개 변수가 있는 함수
void show_message(string message)
{
    cout << message << endl; // 넘어온 매개 변수의 값을 출력
}

int main()
{
    show_message("매개 변수"); // show_message() 함수에 "매개 변수" 문자열 전달
    show_message("Parameter"); // show_message() 함수에 "Parameter" 문자열 전달
    return 0;
}

매개 변수
Parameter

함수의 괄호 안에는 매개 변수를 선언할 수 있는데, show_message(string message) 형태로 함수 호출시 문자열을 받아서 message 변수에 저장합니다. 함수를 호출할 때 동일한 데이터 형식을 전달해야 합니다. 함수의 매개 변수는 콤마 기호를 구분으로 하나 이상을 줄 수 있습니다.

이번에는 매개 변수(Parameter)가 있는 함수를 만들고 사용해보겠습니다.

코드: function_parameter.go

package main

import "fmt"

// 매개 변수가 있는 함수
func showMessage(message string) {
    fmt.Println(message) // 넘어온 매개 변수의 값을 출력
}

func main() {
    showMessage("매개 변수") // showMessage() 함수에 "매개 변수" 문자열 전달
    showMessage("Parameter") // showMessage() 함수에 "Parameter" 문자열 전달
}

매개 변수
Parameter

함수의 괄호 안에는 매개 변수를 선언할 수 있는데, showMessage(message string) 형태로 함수 호출시 문자열을 받아서 message 변수에 저장합니다. 함수를 호출할 때 동일한 데이터 형식을 전달해야 합니다. 함수의 매개 변수는 콤마 기호를 구분으로 하나 이상을 줄 수 있습니다.

이번에는 매개 변수(Parameter)가 있는 함수를 만들고 사용해보겠습니다.

코드: function_parameter.rs

// 매개 변수(Parameter)가 있는 함수 만들고 호출하기

fn show_message(message: &str) {
    println!("{}", message); // 넘어온 매개 변수의 값을 출력
}

fn main() {
    show_message("매개 변수"); // show_message() 함수에 "매개 변수" 문자열 전달
    show_message("Parameter"); // show_message() 함수에 "Parameter" 문자열 전달
}

매개 변수
Parameter

함수의 괄호 안에는 매개 변수를 선언할 수 있는데, show_message(message: &str) 형태로 함수 호출시 문자열을 받아서 message 변수에 저장합니다. 함수를 호출할 때 동일한 데이터 형식을 전달해야 합니다. 함수의 매개 변수는 콤마 기호를 구분으로 하나 이상을 줄 수 있습니다.

이번에는 매개 변수(Parameter)가 있는 함수를 만들고 사용해보겠습니다.

코드: function_parameter.ts

// 매개 변수(Parameter)가 있는 함수 만들고 호출하기

function showMessage(message: string): void {
  console.log(message); // 넘어온 매개 변수의 값을 출력
}

showMessage("매개 변수"); // showMessage() 함수에 "매개 변수" 문자열 전달
showMessage("Parameter"); // showMessage() 함수에 "Parameter" 문자열 전달

매개 변수
Parameter

함수의 괄호 안에는 매개 변수를 선언할 수 있는데, showMessage(message: string) 형태로 함수 호출시 문자열을 받아서 message 변수에 저장합니다. 함수를 호출할 때 동일한 데이터 형식을 전달해야 합니다. 함수의 매개 변수는 콤마 기호를 구분으로 하나 이상을 줄 수 있습니다.

이번에는 매개 변수(Parameter)가 있는 함수를 만들고 사용해보겠습니다.

코드: FunctionParameter.kt

// 매개 변수(Parameter)가 있는 함수 만들고 호출하기

fun showMessage(message: String) {
    println(message) // 넘어온 매개 변수의 값을 출력
}

fun main() {
    showMessage("매개 변수") // showMessage() 함수에 "매개 변수" 문자열 전달
    showMessage("Parameter") // showMessage() 함수에 "Parameter" 문자열 전달
}

매개 변수
Parameter

함수의 괄호 안에는 매개 변수를 선언할 수 있는데, showMessage(message: String) 형태로 함수 호출시 문자열을 받아서 message 변수에 저장합니다. 함수를 호출할 때 동일한 데이터 형식을 전달해야 합니다. 함수의 매개 변수는 콤마 기호를 구분으로 하나 이상을 줄 수 있습니다.

문자열 데이터를 반환하는 함수를 만들고 호출해보겠습니다.

코드: ReturnValue.cs

// 반환값이 있는 함수 만들고 호출하기 
using System;

class ReturnValue
{
    static string GetString()
    {
        return "반환값(Return Value)"; // return 키워드로 단순 문자열 반환
    }

    static void Main()
    {
        // GetString() 함수 호출 후 반환된 반환값을 returnValue 변수에 저장
        string returnValue = GetString();
        Console.WriteLine(returnValue);
    }
}

반환값(Return Value)

GetString() 함수를 호출하면 return 키워드에 의해서 "반환값(Return Value)" 문자열이 함수를 호출한 부분으로 반환이 됩니다. 이 반환된 문자열을 returnValue 변수에 담아서 Main() 메서드에서 사용하는 내용입니다.

문자열 데이터를 반환하는 함수를 만들고 호출해보겠습니다.

코드: return_value.c

#include <stdio.h>

// GetString 함수는 단순히 "반환값(Return Value)" 문자열을 반환합니다.
char* GetString()
{
    return "반환값(Return Value)";
}

int main(void)
{
    // GetString 함수 호출 후 반환된 반환값을 returnValue 변수에 저장합니다.
    char* returnValue = GetString();
    printf("%s\n", returnValue);

    return 0;
}

반환값(Return Value)

GetString 함수를 호출하면 함수 내부의 return 키워드에 의해 "반환값(Return Value)" 문자열이 반환됩니다. 이 반환된 문자열은 main 함수에서 char* 타입의 returnValue 변수에 저장되어 출력됩니다.

반환값(Return Value)이 있는 함수 만들기

반환값(Return Value)을 갖는 함수를 만들고 사용해 보겠습니다.

코드: ReturnValue.java

class ReturnValue {
    static String getString() {
        return "반환값(Return Value)"; // return 키워드로 단순 문자열 반환
    }

    public static void main(String[] args) {
        // getString() 함수 호출 후 반환된 반환값을 returnValue 변수에 저장
        String returnValue = getString();
        System.out.println(returnValue);
    }
}

반환값(Return Value)

getString() 함수를 호출하면 return 키워드에 의해서 "반환값(Return Value)" 문자열이 함수를 호출한 부분으로 반환됩니다. 이 반환된 문자열을 returnValue 변수에 담아서 main() 메서드에서 사용합니다.

내용 준비중입니다...

내용 준비중입니다...

내용 준비중입니다...

내용 준비중입니다...

내용 준비중입니다...

내용 준비중입니다...

내용 준비중입니다...

다음 코드는 2개의 실수 데이터를 받아서 그 합을 구한 후 그 값을 결괏값으로 되돌려주는 함수입니다.

코드: GetSumTwoNumber.cs

using System;

class GetSumTwoNumber
{
    // 두 수의 합을 구하는 함수(메서드)
    static double GetSum(double x, double y)
    {
        double r = x + y;
        return r;
    }

    static void Main()
    {
        double result = GetSum(3.0, 0.14);
        Console.WriteLine(result); // 3.14
    }
}

3.14

GetSum() 함수는 2개의 double 형식을 받아서 더한 후 그 결과를 다시 Main() 메서드로 돌려주는 형태입니다.

내용 준비중입니다...

// GetSumTwoNumber.java
// 두 수의 합을 구하는 함수(메서드)
public class GetSumTwoNumber {
    public static double getSum(double x, double y) {
        double r = x + y;
        return r; 
    }

    public static void main(String[] args) {
        System.out.println(getSum(3, 5));       // 8.0
        System.out.println(getSum(3, 0.14));    // 3.14
    }
}

8.0
3.14

코드: GetSumTwoNumber.py

// GetSumTwoNumber.py
>>> # GetSumTwoNumber.py
... # 두 수의 합을 구하는 함수 만들기
... def GetSumTwoNumber(x, y):
...     r = x + y
...     return r
... 
... # 함수 호출 후 결괏값을 받아오기 
>>> result = GetSumTwoNumber(3.0, 0.14)
>>> # 결괏값 출력
... print(result) # 3.14
3.14

내용 준비중입니다...

내용 준비중입니다...

내용 준비중입니다...

내용 준비중입니다...

내용 준비중입니다...

내용 준비중입니다...

이번 예제에서는 팩토리얼을 계산하는 여러 가지 방법을 소개합니다. 팩토리얼은 숫자를 1부터 자기 자신까지 차례로 곱한 결과입니다. 예를 들어, 4! = 4 * 3 * 2 * 1 = 24입니다. 이 예제에서는 재귀 함수를 사용하여 팩토리얼을 계산하는 방법과 다른 두 가지 방법을 소개합니다.

코드: RecursionDemo.cs

// 재귀 함수(Recursion)
using System;

class RecursionDemo
{
    static void Main()
    {
        // 재귀 호출을 사용하여 Factorial을 구하기: 4! = 4 * 3 * 2 * 1 = 24
        Console.WriteLine(4 * 3 * 2 * 1); // 24
        Console.WriteLine(FactorialFor(4));
        Console.WriteLine(Factorial(4));
        Console.WriteLine(Fact(4)); 
    }

    // 3항 연산자를 사용한 Factorial 구하기
    static int Fact(int n)
    {
        return (n > 1) ? n * Fact(n - 1) : 1;
    }

    // 재귀 함수를 사용한 Factorial 함수 만들기: 단, 재귀함수는 Tree 구조 탐색에 유리
    static int Factorial(int n)
    {
        // 종료
        if (n == 0 || n == 1)
        {
            return 1;
        }
        // 재귀 호출
        return n * Factorial(n - 1);
    }

    // 단순한 Factorial은 이 방법이 좋음
    static int FactorialFor(int n)
    {
        int result = 1;
        for (int i = 1; i <= n; i++)
        {
            result *= i; // ((((1 * 1) * 2) * 3) * 4)
        }
        return result;
    }
}

24
24
24
24

위 코드에서는 세 가지 방법으로 팩토리얼을 계산합니다. 첫 번째 방법은 3항 연산자를 사용한 팩토리얼 구하기입니다. 두 번째 방법은 재귀 함수를 사용한 팩토리얼 계산입니다. 재귀 함수는 주로 트리 구조를 탐색하는 데 유리합니다. 마지막 방법은 반복문을 사용한 팩토리얼 계산입니다. 이 방법은 단순한 팩토리얼 계산에 적합합니다. 결과를 확인하면 모든 방법이 동일한 값을 출력하는 것을 확인할 수 있습니다.

이번 예제에서는 팩토리얼을 계산하는 여러 가지 방법을 소개합니다. 팩토리얼은 숫자를 1부터 자기 자신까지 차례로 곱한 결과입니다. 예를 들어, 4! = 4 * 3 * 2 * 1 = 24입니다. 이 예제에서는 재귀 함수를 사용하여 팩토리얼을 계산하는 방법과 다른 두 가지 방법을 소개합니다.

코드: recursion_demo.c

// 재귀 함수(Recursion)를 사용한 팩토리얼 계산
#include <stdio.h>

// 3항 연산자를 사용한 팩토리얼 구하기
int Fact(int n)
{
    return (n > 1) ? n * Fact(n - 1) : 1;
}

// 재귀 함수를 사용한 팩토리얼 함수 만들기: 단, 재귀함수는 Tree 구조 탐색에 유리
int Factorial(int n)
{
    // 종료
    if (n == 0 || n == 1)
    {
        return 1;
    }
    // 재귀 호출
    return n * Factorial(n - 1);
}

// 단순한 팩토리얼은 이 방법이 좋음
int FactorialFor(int n)
{
    int result = 1;
    for (int i = 1; i <= n; i++)
    {
        result *= i; // ((((1 * 1) * 2) * 3) * 4)
    }
    return result;
}

int main(void)
{
    // 재귀 호출을 사용하여 Factorial을 구하기: 4! = 4 * 3 * 2 * 1 = 24
    printf("%d\n", 4 * 3 * 2 * 1); // 24
    printf("%d\n", FactorialFor(4));
    printf("%d\n", Factorial(4));
    printf("%d\n", Fact(4));

    return 0;
}

위 코드에서는 세 가지 방법으로 팩토리얼을 계산합니다. 첫 번째 방법은 3항 연산자를 사용한 팩토리얼 구하기입니다. 두 번째 방법은 재귀 함수를 사용한 팩토리얼 계산입니다. 재귀 함수는 주로 트리 구조를 탐색하는 데 유리합니다. 마지막 방법은 반복문을 사용한 팩토리얼 계산입니다. 이 방법은 단순한 팩토리얼 계산에 적합합니다. 결과를 확인하면 모든 방법이 동일한 값을 출력하는 것을 확인할 수 있습니다.

24
24
24
24

코드: RecursionDemo.java

// 재귀 함수(Recursion)
public class RecursionDemo {
    public static void main(String[] args) {
        // 재귀 호출을 사용하여 Factorial 구하기 : 3! = 3 * 2 * 1 = 6
        System.out.println(3 * 2 * 1);
        System.out.println(FactorialFor(4)); // 24
        System.out.println(Factorial(4)); // 기준
        System.out.println(Fact(10));
    }

    // 3항 연산자를 사용한 Factorial 구하기
    private static int Fact(int n) {
        return (n > 1) ? n * Fact(n - 1) : 1;
    }

    // 재귀 함수를 사용한 Factorial 함수 만들기: 단, 재귀함수는 Tree 구조 탐색에 유리
    private static int Factorial(int n) {
        // 종료
        if (n == 0 || n == 1) {
            return 1; // 0! => 1로 설정
        }
        // 재귀호출
        return n * Factorial(n - 1); // n! = 4 * (4-1)
    }

    // 팩토리얼을 일반적인 코드로 사용
    private static int FactorialFor(int n) {
        int result = 1;
        for (int i = 1; i <= n; i++) {
            result *= i; // 1 * 2 * 3 * .. * n
        }
        return result;
    }
}

6
24     
24     
3628800

Fact() 함수와 Factorial() 함수는 둘 다 함수 내에서 자기 자신을 호출합니다. 이러한 과정을 통해서 숫자 4를 넘겨주면 4 * 3 * 2 * 1을 만들어주는 형태로 팩토리얼을 구할 수 있습니다. 재귀 호출은 스택(Stack) 메모리에 저장되는 형태로 실행이 됩니다. 너무 많은 재귀 처리는 스택 오버플로(Stack Overflow) 에러가 발생하기 쉽습니다. 그러기에 많은 양의 데이터 처리를 위한 코드 작성시에는 재귀 호출보다는 반복문 등으로 풀어 쓰는게 훨씬 좋습니다.

이번 예제에서는 팩토리얼을 계산하는 여러 가지 방법을 소개합니다. 팩토리얼은 숫자를 1부터 자기 자신까지 차례로 곱한 결과입니다. 예를 들어, 4! = 4 * 3 * 2 * 1 = 24입니다. 이 예제에서는 재귀 함수를 사용하여 팩토리얼을 계산하는 방법과 다른 두 가지 방법을 소개합니다.

코드: recursion_demo.py

# 재귀 함수(Recursion)를 사용한 팩토리얼 계산

# 3항 연산자를 사용한 팩토리얼 구하기
def fact(n):
    return n * fact(n - 1) if n > 1 else 1

# 재귀 함수를 사용한 팩토리얼 함수 만들기: 단, 재귀함수는 Tree 구조 탐색에 유리
def factorial(n):
    # 종료
    if n == 0 or n == 1:
        return 1
    # 재귀 호출
    return n * factorial(n - 1)

# 단순한 팩토리얼은 이 방법이 좋음
def factorial_for(n):
    result = 1
    for i in range(1, n + 1):
        result *= i  # ((((1 * 1) * 2) * 3) * 4)
    return result

# 재귀 호출을 사용하여 Factorial을 구하기: 4! = 4 * 3 * 2 * 1 = 24
print(4 * 3 * 2 * 1)  # 24
print(factorial_for(4))
print(factorial(4))
print(fact(4))

위 코드에서는 세 가지 방법으로 팩토리얼을 계산합니다. 첫 번째 방법은 3항 연산자를 사용한 팩토리얼 구하기입니다. 두 번째 방법은 재귀 함수를 사용한 팩토리얼 계산입니다. 재귀 함수는 주로 트리 구조를 탐색하는 데 유리합니다. 마지막 방법은 반복문을 사용한 팩토리얼 계산입니다. 이 방법은 단순한 팩토리얼 계산에 적합합니다. 결과를 확인하면 모든 방법이 동일한 값을 출력하는 것을 확인할 수 있습니다.

24
24
24
24

이번 예제에서는 팩토리얼을 계산하는 여러 가지 방법을 소개합니다. 팩토리얼은 숫자를 1부터 자기 자신까지 차례로 곱한 결과입니다. 예를 들어, 4! = 4 * 3 * 2 * 1 = 24입니다. 이 예제에서는 재귀 함수를 사용하여 팩토리얼을 계산하는 방법과 다른 두 가지 방법을 소개합니다.

코드: recursionDemo.js

// 재귀 함수(Recursion)를 사용한 팩토리얼 계산

// 3항 연산자를 사용한 팩토리얼 구하기
function fact(n) {
    return n > 1 ? n * fact(n - 1) : 1;
}

// 재귀 함수를 사용한 팩토리얼 함수 만들기: 단, 재귀함수는 Tree 구조 탐색에 유리
function factorial(n) {
    // 종료
    if (n === 0 || n === 1) {
        return 1;
    }
    // 재귀 호출
    return n * factorial(n - 1);
}

// 단순한 팩토리얼은 이 방법이 좋음
function factorialFor(n) {
    let result = 1;
    for (let i = 1; i <= n; i++) {
        result *= i; // ((((1 * 1) * 2) * 3) * 4)
    }
    return result;
}

// 재귀 호출을 사용하여 팩토리얼을 구하기: 4! = 4 * 3 * 2 * 1 = 24
console.log(4 * 3 * 2 * 1); // 24
console.log(factorialFor(4));
console.log(factorial(4));
console.log(fact(4));

위 코드에서는 세 가지 방법으로 팩토리얼을 계산합니다. 첫 번째 방법은 3항 연산자를 사용한 팩토리얼 구하기입니다. 두 번째 방법은 재귀 함수를 사용한 팩토리얼 계산입니다. 재귀 함수는 주로 트리 구조를 탐색하는 데 유리합니다. 마지막 방법은 반복문을 사용한 팩토리얼 계산입니다. 이 방법은 단순한 팩토리얼 계산에 적합합니다. 결과를 확인하면 모든 방법이 동일한 값을 출력하는 것을 확인할 수 있습니다.

24
24
24
24

이번 예제에서는 팩토리얼을 계산하는 여러 가지 방법을 소개합니다. 팩토리얼은 숫자를 1부터 자기 자신까지 차례로 곱한 결과입니다. 예를 들어, 4! = 4 * 3 * 2 * 1 = 24입니다. 이 예제에서는 재귀 함수를 사용하여 팩토리얼을 계산하는 방법과 다른 두 가지 방법을 소개합니다.

코드: recursion_demo.cpp

// 재귀 함수(Recursion)를 사용한 팩토리얼 계산
#include <iostream>

// 3항 연산자를 사용한 팩토리얼 구하기
int Fact(int n)
{
    return (n > 1) ? n * Fact(n - 1) : 1;
}

// 재귀 함수를 사용한 팩토리얼 함수 만들기: 단, 재귀함수는 Tree 구조 탐색에 유리
int Factorial(int n)
{
    // 종료
    if (n == 0 || n == 1)
    {
        return 1;
    }
    // 재귀 호출
    return n * Factorial(n - 1);
}

// 단순한 팩토리얼은 이 방법이 좋음
int FactorialFor(int n)
{
    int result = 1;
    for (int i = 1; i <= n; i++)
    {
        result *= i; // ((((1 * 1) * 2) * 3) * 4)
    }
    return result;
}

int main()
{
    // 재귀 호출을 사용하여 Factorial을 구하기: 4! = 4 * 3 * 2 * 1 = 24
    std::cout << 4 * 3 * 2 * 1 << std::endl; // 24
    std::cout << FactorialFor(4) << std::endl;
    std::cout << Factorial(4) << std::endl;
    std::cout << Fact(4) << std::endl;

    return 0;
}

위 코드에서는 세 가지 방법으로 팩토리얼을 계산합니다. 첫 번째 방법은 3항 연산자를 사용한 팩토리얼 구하기입니다. 두 번째 방법은 재귀 함수를 사용한 팩토리얼 계산입니다. 재귀 함수는 주로 트리 구조를 탐색하는 데 유리합니다. 마지막 방법은 반복문을 사용한 팩토리얼 계산입니다. 이 방법은 단순한 팩토리얼 계산에 적합합니다. 결과를 확인하면 모든 방법이 동일한 값을 출력하는 것을 확인할 수 있습니다.

24
24
24
24

이번 예제에서는 팩토리얼을 계산하는 여러 가지 방법을 소개합니다. 팩토리얼은 숫자를 1부터 자기 자신까지 차례로 곱한 결과입니다. 예를 들어, 4! = 4 * 3 * 2 * 1 = 24입니다. 이 예제에서는 재귀 함수를 사용하여 팩토리얼을 계산하는 방법과 다른 두 가지 방법을 소개합니다.

코드: recursion_demo.rs

// 재귀 함수(Recursion)를 사용한 팩토리얼 계산

// 3항 연산자를 사용한 팩토리얼 구하기
fn fact(n: u32) -> u32 {
    if n > 1 {
        n * fact(n - 1)
    } else {
        1
    }
}

// 재귀 함수를 사용한 팩토리얼 함수 만들기: 단, 재귀함수는 Tree 구조 탐색에 유리
fn factorial(n: u32) -> u32 {
    // 종료
    if n == 0 || n == 1 {
        return 1;
    }
    // 재귀 호출
    n * factorial(n - 1)
}

// 단순한 팩토리얼은 이 방법이 좋음
fn factorial_for(n: u32) -> u32 {
    let mut result = 1;
    for i in 1..=n {
        result *= i; // ((((1 * 1) * 2) * 3) * 4)
    }
    result
}

fn main() {
    // 재귀 호출을 사용하여 팩토리얼을 구하기: 4! = 4 * 3 * 2 * 1 = 24
    println!("{}", 4 * 3 * 2 * 1); // 24
    println!("{}", factorial_for(4));
    println!("{}", factorial(4));
    println!("{}", fact(4));
}

위 코드에서는 세 가지 방법으로 팩토리얼을 계산합니다. 첫 번째 방법은 3항 연산자를 사용한 팩토리얼 구하기입니다. 두 번째 방법은 재귀 함수를 사용한 팩토리얼 계산입니다. 재귀 함수는 주로 트리 구조를 탐색하는 데 유리합니다. 마지막 방법은 반복문을 사용한 팩토리얼 계산입니다. 이 방법은 단순한 팩토리얼 계산에 적합합니다. 결과를 확인하면 모든 방법이 동일한 값을 출력하는 것을 확인할 수 있습니다.

24
24
24
24

이번 예제에서는 팩토리얼을 계산하는 여러 가지 방법을 소개합니다. 팩토리얼은 숫자를 1부터 자기 자신까지 차례로 곱한 결과입니다. 예를 들어, 4! = 4 * 3 * 2 * 1 = 24입니다. 이 예제에서는 재귀 함수를 사용하여 팩토리얼을 계산하는 방법과 다른 두 가지 방법을 소개합니다.

코드: recursion_demo.go

// 재귀 함수(Recursion)를 사용한 팩토리얼 계산
package main

import "fmt"

// 3항 연산자를 사용한 팩토리얼 구하기
func fact(n int) int {
    if n > 1 {
        return n * fact(n - 1)
    } else {
        return 1
    }
}

// 재귀 함수를 사용한 팩토리얼 함수 만들기: 단, 재귀함수는 Tree 구조 탐색에 유리
func factorial(n int) int {
    // 종료
    if n == 0 || n == 1 {
        return 1
    }
    // 재귀 호출
    return n * factorial(n - 1)
}

// 단순한 팩토리얼은 이 방법이 좋음
func factorialFor(n int) int {
    result := 1
    for i := 1; i <= n; i++ {
        result *= i // ((((1 * 1) * 2) * 3) * 4)
    }
    return result
}

func main() {
    // 재귀 호출을 사용하여 팩토리얼을 구하기: 4! = 4 * 3 * 2 * 1 = 24
    fmt.Println(4 * 3 * 2 * 1) // 24
    fmt.Println(factorialFor(4))
    fmt.Println(factorial(4))
    fmt.Println(fact(4))
}

위 코드에서는 세 가지 방법으로 팩토리얼을 계산합니다. 첫 번째 방법은 3항 연산자를 사용한 팩토리얼 구하기입니다. 두 번째 방법은 재귀 함수를 사용한 팩토리얼 계산입니다. 재귀 함수는 주로 트리 구조를 탐색하는 데 유리합니다. 마지막 방법은 반복문을 사용한 팩토리얼 계산입니다. 이 방법은 단순한 팩토리얼 계산에 적합합니다. 결과를 확인하면 모든 방법이 동일한 값을 출력하는 것을 확인할 수 있습니다.

24
24
24
24

이번 예제에서는 팩토리얼을 계산하는 여러 가지 방법을 소개합니다. 팩토리얼은 숫자를 1부터 자기 자신까지 차례로 곱한 결과입니다. 예를 들어, 4! = 4 * 3 * 2 * 1 = 24입니다. 이 예제에서는 재귀 함수를 사용하여 팩토리얼을 계산하는 방법과 다른 두 가지 방법을 소개합니다.

코드: RecursionDemo.kt

// 재귀 함수(Recursion)를 사용한 팩토리얼 계산
fun main() {
    // 재귀 호출을 사용하여 팩토리얼을 구하기: 4! = 4 * 3 * 2 * 1 = 24
    println(4 * 3 * 2 * 1) // 24
    println(factorialFor(4))
    println(factorial(4))
    println(fact(4))
}

// 3항 연산자를 사용한 팩토리얼 구하기
fun fact(n: Int): Int {
    return if (n > 1) n * fact(n - 1) else 1
}

// 재귀 함수를 사용한 팩토리얼 함수 만들기: 단, 재귀함수는 Tree 구조 탐색에 유리
fun factorial(n: Int): Int {
    // 종료
    if (n == 0 || n == 1) {
        return 1
    }
    // 재귀 호출
    return n * factorial(n - 1)
}

// 단순한 팩토리얼은 이 방법이 좋음
fun factorialFor(n: Int): Int {
    var result = 1
    for (i in 1..n) {
        result *= i // ((((1 * 1) * 2) * 3) * 4)
    }
    return result
}

위 코드에서는 세 가지 방법으로 팩토리얼을 계산합니다. 첫 번째 방법은 3항 연산자를 사용한 팩토리얼 구하기입니다. 두 번째 방법은 재귀 함수를 사용한 팩토리얼 계산입니다. 재귀 함수는 주로 트리 구조를 탐색하는 데 유리합니다. 마지막 방법은 반복문을 사용한 팩토리얼 계산입니다. 이 방법은 단순한 팩토리얼 계산에 적합합니다. 결과를 확인하면 모든 방법이 동일한 값을 출력하는 것을 확인할 수 있습니다.

24
24
24
24

이번 예제에서는 재귀 함수를 사용하여 주어진 숫자의 거듭제곱 값을 계산하는 프로그램을 작성해보겠습니다.

코드: RecursionPower.cs

// 재귀(Recursion)를 활용한 n의 m승 계산하기
using System;

class RecursionPower
{
    static int MyPower(int num, int cnt)
    {
        if (cnt == 0)
        {
            return 1;
        }
        return num * MyPower(num, --cnt); // 2 * (2 * (1))
    }

    static void Main()
    {
        Console.WriteLine(MyPower(2, 2)); // 2 * 2 * 1 = 4
    }
}

4

MyPower() 함수는 숫자 num과 거듭제곱 횟수 cnt를 인자로 받아서 n의 m승을 계산합니다. 예를 들어, MyPower(2, 2)를 전달하면 2의 2승(2 * 2)인 4를 반환합니다. 마찬가지로, MyPower(2, 10)을 전달하면 2를 10번 곱하여 2의 10승을 구해줍니다. 이렇게 재귀 함수를 활용하면 간결하게 거듭제곱 값을 계산할 수 있습니다.

재귀 함수를 활용한 n의 m제곱 계산하기

이번 예제에서는 재귀 함수를 사용하여 주어진 숫자의 거듭제곱 값을 계산하는 프로그램을 작성해보겠습니다.

코드: RecursionPower.c

// 재귀(Recursion)를 활용한 n의 m승 계산하기
#include <stdio.h>

int MyPower(int num, int cnt)
{
    if (cnt == 0)
    {
        return 1;
    }
    return num * MyPower(num, --cnt); // 2 * (2 * (1))
}

int main()
{
    printf("%d\n", MyPower(2, 2)); // 2 * 2 * 1 = 4
    return 0;
}

4

MyPower() 함수는 숫자 num과 거듭제곱 횟수 cnt를 인자로 받아서 n의 m승을 계산합니다. 예를 들어, MyPower(2, 2)를 전달하면 2의 2승(2 * 2)인 4를 반환합니다. 마찬가지로, MyPower(2, 10)을 전달하면 2를 10번 곱하여 2의 10승을 구해줍니다. 이렇게 재귀 함수를 활용하면 간결하게 거듭제곱 값을 계산할 수 있습니다.

재귀 함수를 활용한 n의 m제곱 계산하기

이번 예제에서는 재귀 함수를 사용하여 주어진 숫자의 거듭제곱 값을 계산하는 프로그램을 작성해보겠습니다.

코드: RecursionPower.java

// 재귀(Recursion)를 활용한 n의 m승 계산하기
public class RecursionPower {
    static int myPower(int num, int cnt) {
        if (cnt == 0) {
            return 1;
        }
        return num * myPower(num, --cnt); // 2 * (2 * (1))
    }

    public static void main(String[] args) {
        System.out.println(myPower(2, 2)); // 2 * 2 * 1 = 4
    }
}

4

myPower() 함수는 숫자 num과 거듭제곱 횟수 cnt를 인자로 받아서 n의 m승을 계산합니다. 예를 들어, myPower(2, 2)를 전달하면 2의 2승(2 * 2)인 4를 반환합니다. 마찬가지로, myPower(2, 10)을 전달하면 2를 10번 곱하여 2의 10승을 구해줍니다. 이렇게 재귀 함수를 활용하면 간결하게 거듭제곱 값을 계산할 수 있습니다.

재귀 함수를 활용한 n의 m제곱 계산하기

이번 예제에서는 재귀 함수를 사용하여 주어진 숫자의 거듭제곱 값을 계산하는 프로그램을 작성해보겠습니다.

코드: RecursionPower.py

# 재귀(Recursion)를 활용한 n의 m승 계산하기
def my_power(num, cnt):
    if cnt == 0:
        return 1
    return num * my_power(num, cnt - 1)  # 2 * (2 * (1))

print(my_power(2, 2))  # 2 * 2 * 1 = 4

4

my_power() 함수는 숫자 num과 거듭제곱 횟수 cnt를 인자로 받아서 n의 m승을 계산합니다. 예를 들어, my_power(2, 2)를 전달하면 2의 2승(2 * 2)인 4를 반환합니다. 마찬가지로, my_power(2, 10)을 전달하면 2를 10번 곱하여 2의 10승을 구해줍니다. 이렇게 재귀 함수를 활용하면 간결하게 거듭제곱 값을 계산할 수 있습니다.

재귀 함수를 활용한 n의 m제곱 계산하기

이번 예제에서는 재귀 함수를 사용하여 주어진 숫자의 거듭제곱 값을 계산하는 프로그램을 작성해보겠습니다.

코드: RecursionPower.js

// 재귀(Recursion)를 활용한 n의 m승 계산하기
function myPower(num, cnt) {
    if (cnt === 0) {
        return 1;
    }
    return num * myPower(num, cnt - 1); // 2 * (2 * (1))
}

console.log(myPower(2, 2)); // 2 * 2 * 1 = 4

4

myPower() 함수는 숫자 num과 거듭제곱 횟수 cnt를 인자로 받아서 n의 m승을 계산합니다. 예를 들어, myPower(2, 2)를 전달하면 2의 2승(2 * 2)인 4를 반환합니다. 마찬가지로, myPower(2, 10)을 전달하면 2를 10번 곱하여 2의 10승을 구해줍니다. 이렇게 재귀 함수를 활용하면 간결하게 거듭제곱 값을 계산할 수 있습니다.

13.2. 재귀 함수를 활용한 n의 m제곱 계산하기

이번 예제에서는 재귀 함수를 사용하여 주어진 숫자의 거듭제곱 값을 계산하는 프로그램을 작성해보겠습니다.

코드: RecursionPower.cpp

// 재귀(Recursion)를 활용한 n의 m승 계산하기
#include <iostream>

int myPower(int num, int cnt) {
    if (cnt == 0) {
        return 1;
    }
    return num * myPower(num, --cnt); // 2 * (2 * (1))
}

int main() {
    std::cout << myPower(2, 2) << std::endl; // 2 * 2 * 1 = 4
    return 0;
}

4

myPower() 함수는 숫자 num과 거듭제곱 횟수 cnt를 인자로 받아서 n의 m승을 계산합니다. 예를 들어, myPower(2, 2)를 전달하면 2의 2승(2 * 2)인 4를 반환합니다. 마찬가지로, myPower(2, 10)을 전달하면 2를 10번 곱하여 2의 10승을 구해줍니다. 이렇게 재귀 함수를 활용하면 간결하게 거듭제곱 값을 계산할 수 있습니다.

재귀 함수를 활용한 n의 m제곱 계산하기

이번 예제에서는 재귀 함수를 사용하여 주어진 숫자의 거듭제곱 값을 계산하는 프로그램을 작성해보겠습니다.

코드: RecursionPower.go

// 재귀(Recursion)를 활용한 n의 m승 계산하기
package main

import "fmt"

func myPower(num, cnt int) int {
    if cnt == 0 {
        return 1
    }
    return num * myPower(num, cnt-1) // 2 * (2 * (1))
}

func main() {
    fmt.Println(myPower(2, 2)) // 2 * 2 * 1 = 4
}

4

myPower() 함수는 숫자 num과 거듭제곱 횟수 cnt를 인자로 받아서 n의 m승을 계산합니다. 예를 들어, myPower(2, 2)를 전달하면 2의 2승(2 * 2)인 4를 반환합니다. 마찬가지로, myPower(2, 10)을 전달하면 2를 10번 곱하여 2의 10승을 구해줍니다. 이렇게 재귀 함수를 활용하면 간결하게 거듭제곱 값을 계산할 수 있습니다.

재귀 함수를 활용한 n의 m제곱 계산하기

이번 예제에서는 재귀 함수를 사용하여 주어진 숫자의 거듭제곱 값을 계산하는 프로그램을 작성해보겠습니다.

코드: RecursionPower.rs

// 재귀(Recursion)를 활용한 n의 m승 계산하기
fn my_power(num: i32, cnt: i32) -> i32 {
    if cnt == 0 {
        return 1;
    }
    num * my_power(num, cnt - 1) // 2 * (2 * (1))
}

fn main() {
    println!("{}", my_power(2, 2)); // 2 * 2 * 1 = 4
}

4

my_power() 함수는 숫자 num과 거듭제곱 횟수 cnt를 인자로 받아서 n의 m승을 계산합니다. 예를 들어, my_power(2, 2)를 전달하면 2의 2승(2 * 2)인 4를 반환합니다. 마찬가지로, my_power(2, 10)을 전달하면 2를 10번 곱하여 2의 10승을 구해줍니다. 이렇게 재귀 함수를 활용하면 간결하게 거듭제곱 값을 계산할 수 있습니다.

재귀 함수를 활용한 n의 m제곱 계산하기

이번 예제에서는 재귀 함수를 사용하여 주어진 숫자의 거듭제곱 값을 계산하는 프로그램을 작성해보겠습니다.

코드: RecursionPower.ts

// 재귀(Recursion)를 활용한 n의 m승 계산하기
function myPower(num: number, cnt: number): number {
    if (cnt === 0) {
        return 1;
    }
    return num * myPower(num, cnt - 1); // 2 * (2 * (1))
}

console.log(myPower(2, 2)); // 2 * 2 * 1 = 4

4

myPower() 함수는 숫자 num과 거듭제곱 횟수 cnt를 인자로 받아서 n의 m승을 계산합니다. 예를 들어, myPower(2, 2)를 전달하면 2의 2승(2 * 2)인 4를 반환합니다. 마찬가지로, myPower(2, 10)을 전달하면 2를 10번 곱하여 2의 10승을 구해줍니다. 이렇게 재귀 함수를 활용하면 간결하게 거듭제곱 값을 계산할 수 있습니다.

재귀 함수를 활용한 n의 m제곱 계산하기

이번 예제에서는 재귀 함수를 사용하여 주어진 숫자의 거듭제곱 값을 계산하는 프로그램을 작성해보겠습니다.

코드: RecursionPower.kt

// 재귀(Recursion)를 활용한 n의 m승 계산하기
fun myPower(num: Int, cnt: Int): Int {
    if (cnt == 0) {
        return 1
    }
    return num * myPower(num, cnt - 1) // 2 * (2 * (1))
}

fun main() {
    println(myPower(2, 2)) // 2 * 2 * 1 = 4
}

4

myPower() 함수는 숫자 num과 거듭제곱 횟수 cnt를 인자로 받아서 n의 m승을 계산합니다. 예를 들어, myPower(2, 2)를 전달하면 2의 2승(2 * 2)인 4를 반환합니다. 마찬가지로, myPower(2, 10)을 전달하면 2를 10번 곱하여 2의 10승을 구해줍니다. 이렇게 재귀 함수를 활용하면 간결하게 거듭제곱 값을 계산할 수 있습니다.