1# विकास-केंद्रित प्रकल्प नाव जनरेटरसाठी R कार्य
2generate_project_name <- function(prefix = "", suffix = "") {
3  tech_prefixes <- c("React", "Angular", "Vue", "Node", "Express", "Django", "Spring")
4  tech_roles <- c("Frontend", "Backend", "API", "Service", "Microservice", "Engine", "Framework")
5  
6  tech_prefix <- sample(tech_prefixes, 1)
7  tech_role <- sample(tech_roles, 1)
8  
9  if (prefix != "" && !endsWith(prefix, "-")) {
10    prefix <- paste0(prefix, "-")
11  }
12  
13  if (suffix != "" && !startsWith(suffix, "-")) {
14    suffix <- paste0("-", suffix)
15  }
16  
17  paste0(prefix, tech_prefix, "-", tech_role, suffix)
18}
19
20# उदाहरण वापर
21print(generate_project_name("my", "app"))
22

1% विकास-केंद्रित प्रकल्प नाव जनरेटरसाठी MATLAB कार्य
2function projectName = generateProjectName(prefix, suffix)
3    if nargin < 1
4        prefix = "";
5    end
6    if nargin < 2
7        suffix = "";
8    end
9    
10    techPrefixes = {'React', 'Angular', 'Vue', 'Node', 'Express', 'Django', 'Spring'};
11    techRoles = {'Frontend', 'Backend', 'API', 'Service', 'Microservice', 'Engine', 'Framework'};
12    
13    techPrefix = techPrefixes{randi(length(techPrefixes))};
14    techRole = techRoles{randi(length(techRoles))};
15    
16    if ~isempty(prefix) && ~endsWith(prefix, "-")
17        prefix = prefix + "-";
18    end
19    
20    if ~isempty(suffix) && ~startsWith(suffix, "-")
21        suffix = "-" + suffix;
22    end
23    
24    projectName = prefix + techPrefix + "-" + techRole + suffix;
25end
26
27% उदाहरण वापर
28disp(generateProjectName("my", "app"));
29

1import random
2
3def generate_project_name(prefix="", suffix=""):
4    tech_prefixes = ["React", "Angular", "Vue", "Node", "Express", "Django", "Spring"]
5    tech_roles = ["Frontend", "Backend", "API", "Service", "Microservice", "Engine", "Framework"]
6    
7    tech_prefix = random.choice(tech_prefixes)
8    tech_role = random.choice(tech_roles)
9    
10    if prefix and not prefix.endswith("-"):
11        prefix += "-"
12    
13    if suffix and not suffix.startswith("-"):
14        suffix = "-" + suffix
15    
16    return f"{prefix}{tech_prefix}-{tech_role}{suffix}"
17
18# उदाहरण वापर
19print(generate_project_name("my", "app"))
20

1function generateProjectName(prefix = "", suffix = "") {
2  const techPrefixes = ["React", "Angular", "Vue", "Node", "Express", "Django", "Spring"];
3  const techRoles = ["Frontend", "Backend", "API", "Service", "Microservice", "Engine", "Framework"];
4  
5  const techPrefix = techPrefixes[Math.floor(Math.random() * techPrefixes.length)];
6  const techRole = techRoles[Math.floor(Math.random() * techRoles.length)];
7  
8  if (prefix && !prefix.endsWith("-")) {
9    prefix += "-";
10  }
11  
12  if (suffix && !suffix.startsWith("-")) {
13    suffix = "-" + suffix;
14  }
15  
16  return `${prefix}${techPrefix}-${techRole}${suffix}`;
17}
18
19// उदाहरण वापर
20console.log(generateProjectName("my", "app"));
21

1import java.util.Random;
2
3public class ProjectNameGenerator {
4    private static final String[] TECH_PREFIXES = {"React", "Angular", "Vue", "Node", "Express", "Django", "Spring"};
5    private static final String[] TECH_ROLES = {"Frontend", "Backend", "API", "Service", "Microservice", "Engine", "Framework"};
6    private static final Random RANDOM = new Random();
7
8    public static String generateProjectName(String prefix, String suffix) {
9        String techPrefix = TECH_PREFIXES[RANDOM.nextInt(TECH_PREFIXES.length)];
10        String techRole = TECH_ROLES[RANDOM.nextInt(TECH_ROLES.length)];
11        
12        if (prefix != null && !prefix.isEmpty() && !prefix.endsWith("-")) {
13            prefix += "-";
14        }
15        
16        if (suffix != null && !suffix.isEmpty() && !suffix.startsWith("-")) {
17            suffix = "-" + suffix;
18        }
19        
20        return prefix + techPrefix + "-" + techRole + suffix;
21    }
22
23    public static void main(String[] args) {
24        System.out.println(generateProjectName("my", "app"));
25    }
26}
27

1#include <iostream>
2#include <vector>
3#include <string>
4#include <random>
5#include <chrono>
6
7std::string generateProjectName(const std::string& prefix = "", const std::string& suffix = "") {
8    std::vector<std::string> techPrefixes = {"React", "Angular", "Vue", "Node", "Express", "Django", "Spring"};
9    std::vector<std::string> techRoles = {"Frontend", "Backend", "API", "Service", "Microservice", "Engine", "Framework"};
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> prefixDist(0, techPrefixes.size() - 1);
15    std::uniform_int_distribution<int> roleDist(0, techRoles.size() - 1);
16
17    std::string techPrefix = techPrefixes[prefixDist(generator)];
18    std::string techRole = techRoles[roleDist(generator)];
19    
20    std::string finalPrefix = prefix;
21    if (!finalPrefix.empty() && !finalPrefix.back() != '-') {
22        finalPrefix += "-";
23    }
24    
25    std::string finalSuffix = suffix;
26    if (!finalSuffix.empty() && !finalSuffix.front() != '-') {
27        finalSuffix = "-" + finalSuffix;
28    }
29    
30    return finalPrefix + techPrefix + "-" + techRole + finalSuffix;
31}
32
33int main() {
34    std::cout << generateProjectName("my", "app") << std::endl;
35    return 0;
36}
37

1using System;
2
3class ProjectNameGenerator
4{
5    static readonly string[] TechPrefixes = { "React", "Angular", "Vue", "Node", "Express", "Django", "Spring" };
6    static readonly string[] TechRoles = { "Frontend", "Backend", "API", "Service", "Microservice", "Engine", "Framework" };
7    static readonly Random Random = new Random();
8
9    static string GenerateProjectName(string prefix = "", string suffix = "")
10    {
11        string techPrefix = TechPrefixes[Random.Next(TechPrefixes.Length)];
12        string techRole = TechRoles[Random.Next(TechRoles.Length)];
13        
14        if (!string.IsNullOrEmpty(prefix) && !prefix.EndsWith("-"))
15        {
16            prefix += "-";
17        }
18        
19        if (!string.IsNullOrEmpty(suffix) && !suffix.StartsWith("-"))
20        {
21            suffix = "-" + suffix;
22        }
23        
24        return $"{prefix}{techPrefix}-{techRole}{suffix}";
25    }
26
27    static void Main()
28    {
29        Console.WriteLine(GenerateProjectName("my", "app"));
30    }
31}
32

1class ProjectNameGenerator
2  TECH_PREFIXES = %w[React Angular Vue Node Express Django Spring]
3  TECH_ROLES = %w[Frontend Backend API Service Microservice Engine Framework]
4
5  def self.generate(prefix = "", suffix = "")
6    tech_prefix = TECH_PREFIXES.sample
7    tech_role = TECH_ROLES.sample
8    
9    prefix += "-" if !prefix.empty? && !prefix.end_with?("-")
10    suffix = "-" + suffix if !suffix.empty? && !suffix.start_with?("-")
11    
12    "#{prefix}#{tech_prefix}-#{tech_role}#{suffix}"
13  end
14end
15
16# उदाहरण वापर
17puts ProjectNameGenerator.generate("my", "app")
18

1package main
2
3import (
4	"fmt"
5	"math/rand"
6	"strings"
7	"time"
8)
9
10var techPrefixes = []string{"React", "Angular", "Vue", "Node", "Express", "Django", "Spring"}
11var techRoles = []string{"Frontend", "Backend", "API", "Service", "Microservice", "Engine", "Framework"}
12
13func generateProjectName(prefix, suffix string) string {
14	rand.Seed(time.Now().UnixNano())
15	
16	techPrefix := techPrefixes[rand.Intn(len(techPrefixes))]
17	techRole := techRoles[rand.Intn(len(techRoles))]
18	
19	if prefix != "" && !strings.HasSuffix(prefix, "-") {
20		prefix += "-"
21	}
22	
23	if suffix != "" && !strings.HasPrefix(suffix, "-") {
24		suffix = "-" + suffix
25	}
26	
27	return prefix + techPrefix + "-" + techRole + suffix
28}
29
30func main() {
31	fmt.Println(generateProjectName("my", "app"))
32}
33

1import Foundation
2
3struct ProjectNameGenerator {
4    static let techPrefixes = ["React", "Angular", "Vue", "Node", "Express", "Django", "Spring"]
5    static let techRoles = ["Frontend", "Backend", "API", "Service", "Microservice", "Engine", "Framework"]
6    
7    static func generate(prefix: String = "", suffix: String = "") -> String {
8        guard let techPrefix = techPrefixes.randomElement(),
9              let techRole = techRoles.randomElement() else {
10            return "Unknown-Project"
11        }
12        
13        var finalPrefix = prefix
14        if !finalPrefix.isEmpty && !finalPrefix.hasSuffix("-") {
15            finalPrefix += "-"
16        }
17        
18        var finalSuffix = suffix
19        if !finalSuffix.isEmpty && !finalSuffix.hasPrefix("-") {
20            finalSuffix = "-" + finalSuffix
21        }
22        
23        return "\(finalPrefix)\(techPrefix)-\(techRole)\(finalSuffix)"
24    }
25}
26
27// उदाहरण वापर
28print(ProjectNameGenerator.generate(prefix: "my", suffix: "app"))
29

1use rand::seq::SliceRandom;
2
3fn generate_project_name(prefix: &str, suffix: &str) -> String {
4    let tech_prefixes = vec!["React", "Angular", "Vue", "Node", "Express", "Django", "Spring"];
5    let tech_roles = vec!["Frontend", "Backend", "API", "Service", "Microservice", "Engine", "Framework"];
6    
7    let mut rng = rand::thread_rng();
8    
9    let tech_prefix = tech_prefixes.choose(&mut rng).unwrap_or(&"Unknown");
10    let tech_role = tech_roles.choose(&mut rng).unwrap_or(&"Project");
11    
12    let mut final_prefix = prefix.to_string();
13    if !final_prefix.is_empty() && !final_prefix.ends_with("-") {
14        final_prefix.push_str("-");
15    }
16    
17    let mut final_suffix = suffix.to_string();
18    if !final_suffix.is_empty() && !final_suffix.starts_with("-") {
19        final_suffix = format!("-{}", final_suffix);
20    }
21    
22    format!("{}{}-{}{}", final_prefix, tech_prefix, tech_role, final_suffix)
23}
24
25fn main() {
26    println!("{}", generate_project_name("my", "app"));
27}
28

1<?php
2
3class ProjectNameGenerator {
4    private static $techPrefixes = ['React', 'Angular', 'Vue', 'Node', 'Express', 'Django', 'Spring'];
5    private static $techRoles = ['Frontend', 'Backend', 'API', 'Service', 'Microservice', 'Engine', 'Framework'];
6
7    public static function generate($prefix = '', $suffix = '') {
8        $techPrefix = self::$techPrefixes[array_rand(self::$techPrefixes)];
9        $techRole = self::$techRoles[array_rand(self::$techRoles)];
10        
11        if ($prefix !== '' && !str_ends_with($prefix, '-')) {
12            $prefix .= '-';
13        }
14        
15        if ($suffix !== '' && !str_starts_with($suffix, '-')) {
16            $suffix = '-' . $suffix;
17        }
18        
19        return $prefix . $techPrefix . '-' . $techRole . $suffix;
20    }
21}
22
23// उदाहरण वापर
24echo ProjectNameGenerator::generate('my', 'app');
25