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 'Arctic';
12  if (latitude < -66.5) return 'Antarctica';
13  
14  if (latitude > 0) {
15    // Northern Hemisphere
16    if (longitude > -30 && longitude < 60) return 'Europe';
17    if (longitude >= 60 && longitude < 150) return 'Asia';
18    return 'North America';
19  } else {
20    // Southern Hemisphere
21    if (longitude > -30 && longitude < 60) return 'Africa';
22    if (longitude >= 60 && longitude < 150) return 'Oceania';
23    return 'South America';
24  }
25}
26
27function getLocationInfo(latitude, longitude) {
28  const region = determineRegion(latitude, longitude);
29  
30  // Simplified mapping of regions to countries and cities
31  const regionData = {
32    'North America': {
33      countries: ['United States', 'Canada', 'Mexico'],
34      cities: ['New York', 'Los Angeles', 'Toronto', 'Mexico City'],
35      terrains: ['Mountains', 'Plains', 'Forest', 'Desert', 'Coastal']
36    },
37    'Europe': {
38      countries: ['United Kingdom', 'France', 'Germany', 'Italy'],
39      cities: ['London', 'Paris', 'Berlin', 'Rome'],
40      terrains: ['Mountains', 'Plains', 'Forest', 'Coastal']
41    },
42    // Add other regions as needed
43  };
44  
45  const data = regionData[region] || {
46    countries: ['Unknown'],
47    cities: ['Unknown'],
48    terrains: ['Unknown']
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  // Calculate local time based on longitude
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  return {
62    region,
63    country,
64    city,
65    localTime: localDate.getUTCHours().toString().padStart(2, '0') + ':' +
66               localDate.getUTCMinutes().toString().padStart(2, '0'),
67    terrain
68  };
69}
70
71// Usage example
72const coords = generateRandomCoordinates();
73const locationInfo = getLocationInfo(coords.latitude, coords.longitude);
74
75console.log(`Coordinates: ${coords.latitude}, ${coords.longitude}`);
76console.log(`Country: ${locationInfo.country}`);
77console.log(`Nearest City: ${locationInfo.city}`);
78console.log(`Local Time: ${locationInfo.localTime}`);
79console.log(`Terrain: ${locationInfo.terrain}`);
80

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 "Arctic";
52        if (latitude < -66.5) return "Antarctica";
53        
54        if (latitude > 0) {
55            // Northern Hemisphere
56            if (longitude > -30 && longitude < 60) return "Europe";
57            if (longitude >= 60 && longitude < 150) return "Asia";
58            return "North America";
59        } else {
60            // Southern Hemisphere
61            if (longitude > -30 && longitude < 60) return "Africa";
62            if (longitude >= 60 && longitude < 150) return "Oceania";
63            return "South America";
64        }
65    }
66    
67    public static LocationInfo getLocationInfo(Coordinates coords) {
68        String region = determineRegion(coords.latitude, coords.longitude);
69        
70        // Simplified mapping of regions to countries and cities
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("United States", "Canada", "Mexico"));
75        northAmerica.put("cities", Arrays.asList("New York", "Los Angeles", "Toronto", "Mexico City"));
76        northAmerica.put("terrains", Arrays.asList("Mountains", "Plains", "Forest", "Desert", "Coastal"));
77        regionData.put("North America", northAmerica);
78        
79        Map<String, List<String>> europe = new HashMap<>();
80        europe.put("countries", Arrays.asList("United Kingdom", "France", "Germany", "Italy"));
81        europe.put("cities", Arrays.asList("London", "Paris", "Berlin", "Rome"));
82        europe.put("terrains", Arrays.asList("Mountains", "Plains", "Forest", "Coastal"));
83        regionData.put("Europe", europe);
84        
85        // Add other regions as needed
86        
87        Map<String, List<String>> data = regionData.get(region);
88        if (data == null) {
89            data = new HashMap<>();
90            data.put("countries", Arrays.asList("Unknown"));
91            data.put("cities", Arrays.asList("Unknown"));
92            data.put("terrains", Arrays.asList("Unknown"));
93        }
94        
95        String country = random.choice(data.get("countries"));
96        String city = random.choice(data.get("cities"));
97        String terrain = random.choice(data.get("terrains"));
98        
99        // Calculate local time based on longitude
100        int hourOffset = (int) Math.round(coords.longitude / 15);
101        ZonedDateTime utcNow = ZonedDateTime.now(ZoneOffset.UTC);
102        ZonedDateTime localDateTime = utcNow.plusHours(hourOffset);
103        String localTime = localDateTime.format(DateTimeFormatter.ofPattern("HH:mm"));
104        
105        return new LocationInfo(region, country, city, localTime, terrain);
106    }
107    
108    public static void main(String[] args) {
109        Coordinates coords = generateRandomCoordinates();
110        LocationInfo info = getLocationInfo(coords);
111        
112        System.out.println("Coordinates: " + coords);
113        System.out.println("Country: " + info.country);
114        System.out.println("Nearest City: " + info.city);
115        System.out.println("Local Time: " + info.localTime);
116        System.out.println("Terrain: " + info.terrain);
117    }
118}
119

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 "Arctic";
32    if (latitude < -66.5) return "Antarctica";
33    
34    if (latitude > 0) {
35        // Northern Hemisphere
36        if (longitude > -30 && longitude < 60) return "Europe";
37        if (longitude >= 60 && longitude < 150) return "Asia";
38        return "North America";
39    } else {
40        // Southern Hemisphere
41        if (longitude > -30 && longitude < 60) return "Africa";
42        if (longitude >= 60 && longitude < 150) return "Oceania";
43        return "South America";
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    // Simplified mapping of regions to countries and cities
55    std::map<std::string, std::map<std::string, std::vector<std::string>>> regionData;
56    
57    regionData["North America"]["countries"] = {"United States", "Canada", "Mexico"};
58    regionData["North America"]["cities"] = {"New York", "Los Angeles", "Toronto", "Mexico City"};
59    regionData["North America"]["terrains"] = {"Mountains", "Plains", "Forest", "Desert", "Coastal"};
60    
61    regionData["Europe"]["countries"] = {"United Kingdom", "France", "Germany", "Italy"};
62    regionData["Europe"]["cities"] = {"London", "Paris", "Berlin", "Rome"};
63    regionData["Europe"]["terrains"] = {"Mountains", "Plains", "Forest", "Coastal"};
64    
65    // Add other regions as needed
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 = "Unknown";
74        city = "Unknown";
75        terrain = "Unknown";
76    }
77    
78    // Calculate local time based on longitude
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 << "Coordinates: " << coords.latitude << ", " << coords.longitude << std::endl;
103    std::cout << "Country: " << info.country << std::endl;
104    std::cout << "Nearest City: " << info.city << std::endl;
105    std::cout << "Local Time: " << info.localTime << std::endl;
106    std::cout << "Terrain: " << 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 "Arctic"
12  elsif latitude < -66.5
13    return "Antarctica"
14  end
15  
16  if latitude > 0
17    # Northern Hemisphere
18    if longitude > -30 && longitude < 60
19      return "Europe"
20    elsif longitude >= 60 && longitude < 150
21      return "Asia"
22    else
23      return "North America"
24    end
25  else
26    # Southern Hemisphere
27    if longitude > -30 && longitude < 60
28      return "Africa"
29    elsif longitude >= 60 && longitude < 150
30      return "Oceania"
31    else
32      return "South America"
33    end
34  end
35end
36
37def get_location_info(latitude, longitude)
38  region = determine_region(latitude, longitude)
39  
40  # Simplified mapping of regions to countries and cities
41  region_data = {
42    "North America" => {
43      countries: ["United States", "Canada", "Mexico"],
44      cities: ["New York", "Los Angeles", "Toronto", "Mexico City"],
45      terrains: ["Mountains", "Plains", "Forest", "Desert", "Coastal"]
46    },
47    "Europe" => {
48      countries: ["United Kingdom", "France", "Germany", "Italy"],
49      cities: ["London", "Paris", "Berlin", "Rome"],
50      terrains: ["Mountains", "Plains", "Forest", "Coastal"]
51    }
52    # Add other regions as needed
53  }
54  
55  data = region_data[region] || {
56    countries: ["Unknown"],
57    cities: ["Unknown"],
58    terrains: ["Unknown"]
59  }
60  
61  country = data[:countries].sample
62  city = data[:cities].sample
63  terrain = data[:terrains].sample
64  
65  # Calculate local time based on longitude
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# Usage example
80lat, lon = generate_random_coordinates
81location_info = get_location_info(lat, lon)
82
83puts "Coordinates: #{lat}, #{lon}"
84puts "Country: #{location_info[:country]}"
85puts "Nearest City: #{location_info[:city]}"
86puts "Local Time: #{location_info[:local_time]}"
87puts "Terrain: #{location_info[:terrain]}"
88