1# R 함수: 랜덤 프로젝트 이름 생성기
2generate_project_name <- function() {
3  adjectives <- c("민첩한", "동적인", "효율적인", "혁신적인", "확장 가능한")
4  nouns <- c("프레임워크", "플랫폼", "솔루션", "시스템", "도구 키트")
5  paste(sample(adjectives, 1), sample(nouns, 1))
6}
7
8# 사용 예시
9print(generate_project_name())
10

1% MATLAB 함수: 랜덤 프로젝트 이름 생성기
2function projectName = generateProjectName()
3    adjectives = {'민첩한', '동적인', '효율적인', '혁신적인', '확장 가능한'};
4    nouns = {'프레임워크', '플랫폼', '솔루션', '시스템', '도구 키트'};
5    projectName = sprintf('%s %s', adjectives{randi(length(adjectives))}, nouns{randi(length(nouns))});
6end
7
8% 사용 예시
9disp(generateProjectName());
10

1import random
2
3adjectives = ["민첩한", "동적인", "효율적인", "혁신적인", "확장 가능한"]
4nouns = ["프레임워크", "플랫폼", "솔루션", "시스템", "도구 키트"]
5
6def generate_project_name():
7    return f"{random.choice(adjectives)} {random.choice(nouns)}"
8
9# 사용 예시
10print(generate_project_name())
11

1const adjectives = ["민첩한", "동적인", "효율적인", "혁신적인", "확장 가능한"];
2const nouns = ["프레임워크", "플랫폼", "솔루션", "시스템", "도구 키트"];
3
4function generateProjectName() {
5  const randomAdjective = adjectives[Math.floor(Math.random() * adjectives.length)];
6  const randomNoun = nouns[Math.floor(Math.random() * nouns.length)];
7  return `${randomAdjective} ${randomNoun}`;
8}
9
10// 사용 예시
11console.log(generateProjectName());
12

1import java.util.Random;
2
3public class ProjectNameGenerator {
4    private static final String[] ADJECTIVES = {"민첩한", "동적인", "효율적인", "혁신적인", "확장 가능한"};
5    private static final String[] NOUNS = {"프레임워크", "플랫폼", "솔루션", "시스템", "도구 키트"};
6    private static final Random RANDOM = new Random();
7
8    public static String generateProjectName() {
9        String adjective = ADJECTIVES[RANDOM.nextInt(ADJECTIVES.length)];
10        String noun = NOUNS[RANDOM.nextInt(NOUNS.length)];
11        return adjective + " " + noun;
12    }
13
14    public static void main(String[] args) {
15        System.out.println(generateProjectName());
16    }
17}
18

1#include <iostream>
2#include <vector>
3#include <string>
4#include <random>
5#include <chrono>
6
7std::string generateProjectName() {
8    std::vector<std::string> adjectives = {"민첩한", "동적인", "효율적인", "혁신적인", "확장 가능한"};
9    std::vector<std::string> nouns = {"프레임워크", "플랫폼", "솔루션", "시스템", "도구 키트"};
10
11    unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
12    std::default_random_engine generator(seed);
13
14    std::uniform_int_distribution<int> adjDist(0, adjectives.size() - 1);
15    std::uniform_int_distribution<int> nounDist(0, nouns.size() - 1);
16
17    return adjectives[adjDist(generator)] + " " + nouns[nounDist(generator)];
18}
19
20int main() {
21    std::cout << generateProjectName() << std::endl;
22    return 0;
23}
24

1using System;
2
3class ProjectNameGenerator
4{
5    static readonly string[] Adjectives = { "민첩한", "동적인", "효율적인", "혁신적인", "확장 가능한" };
6    static readonly string[] Nouns = { "프레임워크", "플랫폼", "솔루션", "시스템", "도구 키트" };
7    static readonly Random Random = new Random();
8
9    static string GenerateProjectName()
10    {
11        string adjective = Adjectives[Random.Next(Adjectives.Length)];
12        string noun = Nouns[Random.Next(Nouns.Length)];
13        return $"{adjective} {noun}";
14    }
15
16    static void Main()
17    {
18        Console.WriteLine(GenerateProjectName());
19    }
20}
21

1class ProjectNameGenerator
2  ADJECTIVES = %w[민첩한 동적인 효율적인 혁신적인 확장 가능한]
3  NOUNS = %w[프레임워크 플랫폼 솔루션 시스템 도구 키트]
4
5  def self.generate
6    "#{ADJECTIVES.sample} #{NOUNS.sample}"
7  end
8end
9
10# 사용 예시
11puts ProjectNameGenerator.generate
12

1package main
2
3import (
4	"fmt"
5	"math/rand"
6	"time"
7)
8
9var adjectives = []string{"민첩한", "동적인", "효율적인", "혁신적인", "확장 가능한"}
10var nouns = []string{"프레임워크", "플랫폼", "솔루션", "시스템", "도구 키트"}
11
12func generateProjectName() string {
13	rand.Seed(time.Now().UnixNano())
14	return adjectives[rand.Intn(len(adjectives))] + " " + nouns[rand.Intn(len(nouns))]
15}
16
17func main() {
18	fmt.Println(generateProjectName())
19}
20

1import Foundation
2
3struct ProjectNameGenerator {
4    static let adjectives = ["민첩한", "동적인", "효율적인", "혁신적인", "확장 가능한"]
5    static let nouns = ["프레임워크", "플랫폼", "솔루션", "시스템", "도구 키트"]
6    
7    static func generate() -> String {
8        guard let adjective = adjectives.randomElement(),
9              let noun = nouns.randomElement() else {
10            return "이름 없는 프로젝트"
11        }
12        return "\(adjective) \(noun)"
13    }
14}
15
16// 사용 예시
17print(ProjectNameGenerator.generate())
18

1use rand::seq::SliceRandom;
2
3fn generate_project_name() -> String {
4    let adjectives = vec!["민첩한", "동적인", "효율적인", "혁신적인", "확장 가능한"];
5    let nouns = vec!["프레임워크", "플랫폼", "솔루션", "시스템", "도구 키트"];
6    let mut rng = rand::thread_rng();
7
8    format!(
9        "{} {}",
10        adjectives.choose(&mut rng).unwrap_or(&"이름 없는"),
11        nouns.choose(&mut rng).unwrap_or(&"프로젝트")
12    )
13}
14
15fn main() {
16    println!("{}", generate_project_name());
17}
18

1<?php
2
3class ProjectNameGenerator {
4    private static $adjectives = ['민첩한', '동적인', '효율적인', '혁신적인', '확장 가능한'];
5    private static $nouns = ['프레임워크', '플랫폼', '솔루션', '시스템', '도구 키트'];
6
7    public static function generate() {
8        $adjective = self::$adjectives[array_rand(self::$adjectives)];
9        $noun = self::$nouns[array_rand(self::$nouns)];
10        return "$adjective $noun";
11    }
12}
13
14// 사용 예시
15echo ProjectNameGenerator::generate();
16