1function generateRandomCoordinates() {
2  const latitude = Math.random() * 180 - 90;
3  const longitude = Math.random() * 360 - 180;
4  return { 
5    latitude: parseFloat(latitude.toFixed(6)), 
6    longitude: parseFloat(longitude.toFixed(6)) 
7  };
8}
9
10function determineRegion(latitude, longitude) {
11  if (latitude > 66.5) return 'قطب شمال';
12  if (latitude < -66.5) return 'قطب جنوب';
13  
14  if (latitude > 0) {
15    // نیمکره شمالی
16    if (longitude > -30 && longitude < 60) return 'اروپا';
17    if (longitude >= 60 && longitude < 150) return 'آسیا';
18    return 'شمال آمریکا';
19  } else {
20    // نیمکره جنوبی
21    if (longitude > -30 && longitude < 60) return 'آفریقا';
22    if (longitude >= 60 && longitude < 150) return 'اقیانوسیه';
23    return 'جنوب آمریکا';
24  }
25}
26
27function getLocationInfo(latitude, longitude) {
28  const region = determineRegion(latitude, longitude);
29  
30  // نگاشت ساده‌ای از مناطق به کشورها و شهرها
31  const regionData = {
32    'شمال آمریکا': {
33      countries: ['ایالات متحده', 'کانادا', 'مکزیک'],
34      cities: ['نیویورک', 'لس آنجلس', 'تورنتو', 'شهر مکزیک'],
35      terrains: ['کوهستان', 'دشت', 'جنگل', 'بیابان', 'ساحلی']
36    },
37    'اروپا': {
38      countries: ['بریتانیا', 'فرانسه', 'آلمان', 'ایتالیا'],
39      cities: ['لندن', 'پاریس', 'برلین', 'رم'],
40      terrains: ['کوهستان', 'دشت', 'جنگل', 'ساحلی']
41    },
42    // سایر مناطق را در صورت نیاز اضافه کنید
43  };
44  
45  const data = regionData[region] || {
46    countries: ['ناشناخته'],
47    cities: ['ناشناخته'],
48    terrains: ['ناشناخته']
49  };
50  
51  const country = data.countries[Math.floor(Math.random() * data.countries.length)];
52  const city = data.cities[Math.floor(Math.random() * data.cities.length)];
53  const terrain = data.terrains[Math.floor(Math.random() * data.terrains.length)];
54  
55  // محاسبه زمان محلی بر اساس طول جغرافیایی
56  const now = new Date();
57  const hourOffset = Math.round(longitude / 15);
58  const localDate = new Date(now.getTime());
59  localDate.setUTCHours(now.getUTCHours() + hourOffset);
60  
61  const localTime = `${localDate.getUTCHours().toString().padStart(2, '0')}:${localDate.getUTCMinutes().toString().padStart(2, '0')}`;
62  
63  return {
64    region,
65    country,
66    city,
67    localTime,
68    terrain
69  };
70}
71
72// مثال استفاده
73const coords = generateRandomCoordinates();
74const locationInfo = getLocationInfo(coords.latitude, coords.longitude);
75
76console.log(`مختصات: ${coords.latitude}, ${coords.longitude}`);
77console.log(`کشور: ${locationInfo.country}`);
78console.log(`نزدیک‌ترین شهر: ${locationInfo.city}`);
79console.log(`زمان محلی: ${locationInfo.localTime}`);
80console.log(`نوع زمین: ${locationInfo.terrain}`);
81

1import java.time.ZoneOffset;
2import java.time.ZonedDateTime;
3import java.time.format.DateTimeFormatter;
4import java.util.Arrays;
5import java.util.HashMap;
6import java.util.List;
7import java.util.Map;
8import java.util.Random;
9
10public class EnhancedRandomLocationGenerator {
11    private static final Random random = new Random();
12    
13    public static class Coordinates {
14        public final double latitude;
15        public final double longitude;
16        
17        public Coordinates(double latitude, double longitude) {
18            this.latitude = latitude;
19            this.longitude = longitude;
20        }
21        
22        @Override
23        public String toString() {
24            return String.format("%.6f, %.6f", latitude, longitude);
25        }
26    }
27    
28    public static class LocationInfo {
29        public final String region;
30        public final String country;
31        public final String city;
32        public final String localTime;
33        public final String terrain;
34        
35        public LocationInfo(String region, String country, String city, String localTime, String terrain) {
36            this.region = region;
37            this.country = country;
38            this.city = city;
39            this.localTime = localTime;
40            this.terrain = terrain;
41        }
42    }
43    
44    public static Coordinates generateRandomCoordinates() {
45        double latitude = random.nextDouble() * 180 - 90;
46        double longitude = random.nextDouble() * 360 - 180;
47        return new Coordinates(latitude, longitude);
48    }
49    
50    public static String determineRegion(double latitude, double longitude) {
51        if (latitude > 66.5) return "قطب شمال";
52        if (latitude < -66.5) return "قطب جنوب";
53        
54        if (latitude > 0) {
55            // نیمکره شمالی
56            if (longitude > -30 && longitude < 60) return "اروپا";
57            if (longitude >= 60 && longitude < 150) return "آسیا";
58            return "شمال آمریکا";
59        } else {
60            // نیمکره جنوبی
61            if (longitude > -30 && longitude < 60) return "آفریقا";
62            if (longitude >= 60 && longitude < 150) return "اقیانوسیه";
63            return "جنوب آمریکا";
64        }
65    }
66    
67    public static LocationInfo getLocationInfo(Coordinates coords) {
68        String region = determineRegion(coords.latitude, coords.longitude);
69        
70        // نگاشت ساده‌ای از مناطق به کشورها و شهرها
71        Map<String, Map<String, List<String>>> regionData = new HashMap<>();
72        
73        Map<String, List<String>> northAmerica = new HashMap<>();
74        northAmerica.put("countries", Arrays.asList("ایالات متحده", "کانادا", "مکزیک"));
75        northAmerica.put("cities", Arrays.asList("نیویورک", "لس آنجلس", "تورنتو", "شهر مکزیک"));
76        northAmerica.put("terrains", Arrays.asList("کوهستان", "دشت", "جنگل", "بیابان", "ساحلی"));
77        regionData.put("شمال آمریکا", northAmerica);
78        
79        Map<String, List<String>> europe = new HashMap<>();
80        europe.put("countries", Arrays.asList("بریتانیا", "فرانسه", "آلمان", "ایتالیا"));
81        europe.put("cities", Arrays.asList("لندن", "پاریس", "برلین", "رم"));
82        europe.put("terrains", Arrays.asList("کوهستان", "دشت", "جنگل", "ساحلی"));
83        regionData.put("اروپا", europe);
84        
85        // سایر مناطق را در صورت نیاز اضافه کنید
86        
87        Map<String, List<String>> data = regionData.getOrDefault(region, new HashMap<>());
88        List<String> countries = data.getOrDefault("countries", Arrays.asList("ناشناخته"));
89        List<String> cities = data.getOrDefault("cities", Arrays.asList("ناشناخته"));
90        List<String> terrains = data.getOrDefault("terrains", Arrays.asList("ناشناخته"));
91        
92        String country = countries.get(random.nextInt(countries.size()));
93        String city = cities.get(random.nextInt(cities.size()));
94        String terrain = terrains.get(random.nextInt(terrains.size()));
95        
96        // محاسبه زمان محلی بر اساس طول جغرافیایی
97        int hourOffset = (int) Math.round(coords.longitude / 15);
98        ZonedDateTime utcNow = ZonedDateTime.now(ZoneOffset.UTC);
99        ZonedDateTime localDateTime = utcNow.plusHours(hourOffset);
100        String localTime = localDateTime.format(DateTimeFormatter.ofPattern("HH:mm"));
101        
102        return new LocationInfo(region, country, city, localTime, terrain);
103    }
104    
105    public static void main(String[] args) {
106        Coordinates coords = generateRandomCoordinates();
107        LocationInfo info = getLocationInfo(coords);
108        
109        System.out.println("مختصات: " + coords);
110        System.out.println("کشور: " + info.country);
111        System.out.println("نزدیک‌ترین شهر: " + info.city);
112        System.out.println("زمان محلی: " + info.localTime);
113        System.out.println("نوع زمین: " + info.terrain);
114    }
115}
116

1#include <iostream>
2#include <cstdlib>
3#include <ctime>
4#include <string>
5#include <vector>
6#include <map>
7#include <cmath>
8#include <chrono>
9#include <iomanip>
10
11struct Coordinates {
12    double latitude;
13    double longitude;
14};
15
16struct LocationInfo {
17    std::string region;
18    std::string country;
19    std::string city;
20    std::string localTime;
21    std::string terrain;
22};
23
24Coordinates generateRandomCoordinates() {
25    double latitude = (static_cast<double>(rand()) / RAND_MAX) * 180 - 90;
26    double longitude = (static_cast<double>(rand()) / RAND_MAX) * 360 - 180;
27    return {latitude, longitude};
28}
29
30std::string determineRegion(double latitude, double longitude) {
31    if (latitude > 66.5) return "قطب شمال";
32    if (latitude < -66.5) return "قطب جنوب";
33    
34    if (latitude > 0) {
35        // نیمکره شمالی
36        if (longitude > -30 && longitude < 60) return "اروپا";
37        if (longitude >= 60 && longitude < 150) return "آسیا";
38        return "شمال آمریکا";
39    } else {
40        // نیمکره جنوبی
41        if (longitude > -30 && longitude < 60) return "آفریقا";
42        if (longitude >= 60 && longitude < 150) return "اقیانوسیه";
43        return "جنوب آمریکا";
44    }
45}
46
47std::string getRandomElement(const std::vector<std::string>& vec) {
48    return vec[rand() % vec.size()];
49}
50
51LocationInfo getLocationInfo(const Coordinates& coords) {
52    std::string region = determineRegion(coords.latitude, coords.longitude);
53    
54    // نگاشت ساده‌ای از مناطق به کشورها و شهرها
55    std::map<std::string, std::map<std::string, std::vector<std::string>>> regionData;
56    
57    regionData["شمال آمریکا"]["countries"] = {"ایالات متحده", "کانادا", "مکزیک"};
58    regionData["شمال آمریکا"]["cities"] = {"نیویورک", "لس آنجلس", "تورنتو", "شهر مکزیک"};
59    regionData["شمال آمریکا"]["terrains"] = {"کوهستان", "دشت", "جنگل", "بیابان", "ساحلی"};
60    
61    regionData["اروپا"]["countries"] = {"بریتانیا", "فرانسه", "آلمان", "ایتالیا"};
62    regionData["اروپا"]["cities"] = {"لندن", "پاریس", "برلین", "رم"};
63    regionData["اروپا"]["terrains"] = {"کوهستان", "دشت", "جنگل", "ساحلی"};
64    
65    // سایر مناطق را در صورت نیاز اضافه کنید
66    
67    std::string country, city, terrain;
68    if (regionData.find(region) != regionData.end()) {
69        country = getRandomElement(regionData[region]["countries"]);
70        city = getRandomElement(regionData[region]["cities"]);
71        terrain = getRandomElement(regionData[region]["terrains"]);
72    } else {
73        country = "ناشناخته";
74        city = "ناشناخته";
75        terrain = "ناشناخته";
76    }
77    
78    // محاسبه زمان محلی بر اساس طول جغرافیایی
79    auto now = std::chrono::system_clock::now();
80    auto now_time_t = std::chrono::system_clock::to_time_t(now);
81    std::tm utc_tm;
82    gmtime_r(&now_time_t, &utc_tm);
83    
84    int hourOffset = std::round(coords.longitude / 15);
85    utc_tm.tm_hour += hourOffset;
86    mktime(&utc_tm);
87    
88    char timeBuffer[6];
89    std::strftime(timeBuffer, 6, "%H:%M", &utc_tm);
90    std::string localTime(timeBuffer);
91    
92    return {region, country, city, localTime, terrain};
93}
94
95int main() {
96    srand(time(0));
97    
98    Coordinates coords = generateRandomCoordinates();
99    LocationInfo info = getLocationInfo(coords);
100    
101    std::cout << std::fixed << std::setprecision(6);
102    std::cout << "مختصات: " << coords.latitude << ", " << coords.longitude << std::endl;
103    std::cout << "کشور: " << info.country << std::endl;
104    std::cout << "نزدیک‌ترین شهر: " << info.city << std::endl;
105    std::cout << "زمان محلی: " << info.localTime << std::endl;
106    std::cout << "نوع زمین: " << info.terrain << std::endl;
107    
108    return 0;
109}
110

1require 'date'
2
3def generate_random_coordinates
4  latitude = rand(-90.0..90.0)
5  longitude = rand(-180.0..180.0)
6  [latitude.round(6), longitude.round(6)]
7end
8
9def determine_region(latitude, longitude)
10  if latitude > 66.5
11    return "قطب شمال"
12  elsif latitude < -66.5
13    return "قطب جنوب"
14  end
15  
16  if latitude > 0
17    # نیمکره شمالی
18    if longitude > -30 && longitude < 60
19      return "اروپا"
20    elsif longitude >= 60 && longitude < 150
21      return "آسیا"
22    else
23      return "شمال آمریکا"
24    end
25  else
26    # نیمکره جنوبی
27    if longitude > -30 && longitude < 60
28      return "آفریقا"
29    elsif longitude >= 60 && longitude < 150
30      return "اقیانوسیه"
31    else
32      return "جنوب آمریکا"
33    end
34  end
35end
36
37def get_location_info(latitude, longitude)
38  region = determine_region(latitude, longitude)
39  
40  # نگاشت ساده‌ای از مناطق به کشورها و شهرها
41  region_data = {
42    "شمال آمریکا" => {
43      countries: ["ایالات متحده", "کانادا", "مکزیک"],
44      cities: ["نیویورک", "لس آنجلس", "تورنتو", "شهر مکزیک"],
45      terrains: ["کوهستان", "دشت", "جنگل", "بیابان", "ساحلی"]
46    },
47    "اروپا" => {
48      countries: ["بریتانیا", "فرانسه", "آلمان", "ایتالیا"],
49      cities: ["لندن", "پاریس", "برلین", "رم"],
50      terrains: ["کوهستان", "دشت", "جنگل", "ساحلی"]
51    }
52    # سایر مناطق را در صورت نیاز اضافه کنید
53  }
54  
55  data = region_data[region] || {
56    countries: ["ناشناخته"],
57    cities: ["ناشناخته"],
58    terrains: ["ناشناخته"]
59  }
60  
61  country = data[:countries].sample
62  city = data[:cities].sample
63  terrain = data[:terrains].sample
64  
65  # محاسبه زمان محلی بر اساس طول جغرافیایی
66  utc_now = DateTime.now.new_offset(0)
67  hour_offset = (longitude / 15).round
68  local_time = utc_now.new_offset(hour_offset / 24.0)
69  
70  {
71    region: region,
72    country: country,
73    city: city,
74    local_time: local_time.strftime("%H:%M"),
75    terrain: terrain
76  }
77end
78
79# مثال استفاده
80lat, lon = generate_random_coordinates
81location_info = get_location_info(lat, lon)
82
83puts "مختصات: #{lat}, #{lon}"
84puts "کشور: #{location_info[:country]}"
85puts "نزدیک‌ترین شهر: #{location_info[:city]}"
86puts "زمان محلی: #{location_info[:local_time]}"
87puts "نوع زمین: #{location_info[:terrain]}"
88