एक साझा वेब होस्ट पर एक निकटता-आधारित स्टोर स्थान खोज का अनुकूलन?


11

मुझे एक प्रोजेक्ट मिला है जहाँ मुझे क्लाइंट के लिए स्टोर लोकेटर बनाने की आवश्यकता है।

मैं एक कस्टम पोस्ट प्रकार " restaurant-location" का उपयोग कर रहा हूं और मैंने Google जियोकोडिंग एपीआई ( हेन्स की लिंक जो जोंस यूएस व्हाइट हाउस में जियोकोड्स का उपयोग करता है और मैंने अक्षांश और देशांतर वापस संग्रहीत किया है) का उपयोग करते हुए कोड को जियोकोड में संग्रहीत करने के लिए कोड लिखा है। कस्टम फ़ील्ड के लिए।

मैंने एक get_posts_by_geo_distance()फ़ंक्शन लिखा है जो उन पदों के क्रम में एक सूची देता है जो भौगोलिक रूप से निकटतम हैं जो मैंने इस पोस्ट में स्लाइड शो में पाए गए सूत्र का उपयोग कर रहे हैं । आप मेरे फ़ंक्शन को ऐसा कह सकते हैं (मैं एक निश्चित "स्रोत" लेट / लॉन्ग के साथ शुरू कर रहा हूँ):

include "wp-load.php";

$source_lat = 30.3935337;
$source_long = -86.4957833;

$results = get_posts_by_geo_distance(
    'restaurant-location',
    'geo_latitude',
    'geo_longitude',
    $source_lat,
    $source_long);

echo '<ul>';
foreach($results as $post) {
    $edit_url = get_edit_url($post->ID);
    echo "<li>{$post->distance}: <a href=\"{$edit_url}\" target=\"_blank\">{$post->location}</a></li>";
}
echo '</ul>';
return;

यहाँ समारोह get_posts_by_geo_distance()ही है:

function get_posts_by_geo_distance($post_type,$lat_key,$lng_key,$source_lat,$source_lng) {
    global $wpdb;
    $sql =<<<SQL
SELECT
    rl.ID,
    rl.post_title AS location,
    ROUND(3956*2*ASIN(SQRT(POWER(SIN(({$source_lat}-abs(lat.lat))*pi()/180/2),2)+
    COS({$source_lat}*pi()/180)*COS(abs(lat.lat)*pi()/180)*
    POWER(SIN(({$source_lng}-lng.lng)*pi()/180/2),2))),3) AS distance
FROM
    wp_posts rl
    INNER JOIN (SELECT post_id,CAST(meta_value AS DECIMAL(11,7)) AS lat FROM wp_postmeta lat WHERE lat.meta_key='{$lat_key}') lat ON lat.post_id = rl.ID
    INNER JOIN (SELECT post_id,CAST(meta_value AS DECIMAL(11,7)) AS lng FROM wp_postmeta lng WHERE lng.meta_key='{$lng_key}') lng ON lng.post_id = rl.ID
WHERE
    rl.post_type='{$post_type}' AND rl.post_name<>'auto-draft'
ORDER BY
    distance
SQL;
    $sql = $wpdb->prepare($sql,$source_lat,$source_lat,$source_lng);
    return $wpdb->get_results($sql);
}

मेरी चिंता यह है कि एसक्यूएल गैर-अनुकूलित के रूप में आप प्राप्त कर सकते हैं। माईएसक्यूएल किसी भी उपलब्ध सूचकांक द्वारा आदेश नहीं दे सकता है क्योंकि स्रोत जियो परिवर्तनशील है और कैश के लिए स्रोत जियोस का एक निश्चित सेट नहीं है। वर्तमान में मैं इसे अनुकूलित करने के तरीकों के रूप में स्टम्प्ड हूं।

यह ध्यान में रखते हुए कि मैंने पहले से ही क्या किया है: आप इस उपयोग-मामले के अनुकूलन के बारे में कैसे जाएंगे?

यह महत्वपूर्ण नहीं है कि मैं कुछ भी रखूं जो मैंने किया है अगर एक बेहतर समाधान मुझे फेंक देगा। मैं एक को छोड़कर लगभग किसी भी समाधान पर विचार करने के लिए खुला हूं , जिसमें Sphinx सर्वर या कुछ भी करने की आवश्यकता है जैसे कि एक अनुकूलित MySQL कॉन्फ़िगरेशन की आवश्यकता होती है। मूल रूप से समाधान को किसी भी सादे वेनिला वर्डप्रेस इंस्टॉल पर काम करने में सक्षम होना चाहिए। (उस ने कहा, यह बहुत अच्छा होगा अगर कोई भी अन्य लोगों के लिए वैकल्पिक समाधानों को सूचीबद्ध करना चाहता है जो अधिक उन्नत और बाद के लिए सक्षम हो सकते हैं।)

संसाधन मिले

FYI करें, मैंने इस पर थोड़ा शोध किया था, बजाय इसके कि आप फिर से अनुसंधान करें या इसके बजाय कि आपने इनमें से किसी भी लिंक को उत्तर के रूप में पोस्ट किया है जो मैं आगे जाकर उन्हें शामिल करूंगा।

स्फिंक्स खोज के बारे में

जवाबों:


6

आपको किस परिशुद्धता की आवश्यकता है? यदि यह एक राज्य / राष्ट्रीय विस्तृत खोज है, तो हो सकता है कि आप लाइप टू जिप लुकअप कर सकें और ज़िप एरिया से लेकर रेस्तरां के जिप एरिया तक की दूरी तय कर सकें। यदि आपको सटीक दूरी की आवश्यकता है जो एक अच्छा विकल्प नहीं होगा।

आपको जियोकैश समाधान में देखना चाहिए , विकिपीडिया लेख में एक PHP लाइब्रेरी के लिए लिंक है जो कि लंबे समय से जियोशॉट्स को डिकोड करने के लिए एनकोड करता है।

यहाँ आपके पास एक अच्छा लेख है जो यह बताता है कि वे Google App Engine (Python code) में इसका उपयोग क्यों और कैसे करते हैं लेकिन इसका उपयोग करना आसान है।) क्योंकि GAE में जियोहॉश का उपयोग करने की आवश्यकता के कारण आप कुछ अच्छे पायथन लाइब्रेरी और उदाहरण पा सकते हैं।

जैसा कि इस ब्लॉग पोस्ट में बताया गया है, जियोशॉट्स का उपयोग करने का लाभ यह है कि आप उस फ़ील्ड पर MySQL टेबल पर एक इंडेक्स बना सकते हैं।


GeoHash पर सुझाव के लिए धन्यवाद! मैं निश्चित रूप से इसे देख लूंगा, लेकिन अभी एक घंटे में WordCamp सवाना के लिए रवाना नहीं हो सकता। यह एक शहर में आने वाले पर्यटकों के लिए एक रेस्तरां लोकेटर है, इसलिए 0.1 मील संभवतः न्यूनतम परिशुद्धता होगी। आदर्श रूप से यह उससे बेहतर होगा। मैं आपके लिंक संपादित करूँगा!
माइकस्किंकेल

आप एक गूगल मानचित्र में परिणाम प्रदर्शित करने जा रहे हैं आप उनके एपीआई इस्तेमाल कर सकते हैं छँटाई करने के लिए code.google.com/apis/maps/documentation/mapsdata/...

चूंकि यह सबसे दिलचस्प जवाब है, मैं इसे स्वीकार करने जा रहा हूं, भले ही मेरे पास शोध करने और इसे आजमाने का समय नहीं है।
माइकस्किंकेल

9

यह आपके लिए बहुत देर हो सकती है, लेकिन मैं वैसे भी जवाब देने जा रहा हूं, जैसा कि मैंने इस संबंधित प्रश्न को दिया था , इसलिए भविष्य के आगंतुक दोनों प्रश्नों का उल्लेख कर सकते हैं।

मैं इन मूल्यों को पोस्ट मेटाडेटा तालिका में संग्रहीत नहीं करूंगा, या कम से कम केवल वहां नहीं । आप के साथ एक मेज चाहते post_id, lat, lonकॉलम, ताकि आप के एक सूचकांक जगह कर सकते हैं lat, lonकि पर और क्वेरी। यह पोस्ट सेव और अपडेट पर हुक के साथ अद्यतित रखने के लिए बहुत कठिन नहीं होना चाहिए।

जब आप डेटाबेस को क्वेरी करते हैं , तो आप शुरुआती बिंदु के चारों ओर एक बाउंडिंग बॉक्स परिभाषित करते हैं , इसलिए आप बॉक्सlat, lon के उत्तर-दक्षिण और पूर्व-पश्चिम सीमाओं के बीच सभी जोड़ों के लिए एक कुशल क्वेरी कर सकते हैं ।

आपको यह घटा हुआ परिणाम प्राप्त होने के बाद, आप उन स्थानों को फ़िल्टर करने के लिए अधिक उन्नत (परिपत्र या वास्तविक ड्राइविंग निर्देश) दूरी की गणना कर सकते हैं जो बाउंडिंग बॉक्स के कोनों में हैं और आपकी इच्छा से आगे दूर हैं।

यहां आपको एक सरल कोड उदाहरण मिलता है जो व्यवस्थापक क्षेत्र में काम करता है। आपको स्वयं अतिरिक्त डेटाबेस तालिका बनाने की आवश्यकता है। कोड को कम से कम दिलचस्प से ऑर्डर किया गया है।

<?php
/*
Plugin Name: Monkeyman geo test
Plugin URI: http://www.monkeyman.be
Description: Geolocation test
Version: 1.0
Author: Jan Fabry
*/

class Monkeyman_Geo
{
    public function __construct()
    {
        add_action('init', array(&$this, 'registerPostType'));
        add_action('save_post', array(&$this, 'saveLatLon'), 10, 2);

        add_action('admin_menu', array(&$this, 'addAdminPages'));
    }

    /**
     * On post save, save the metadata in our special table
     * (post_id INT, lat DECIMAL(10,5), lon DECIMAL (10,5))
     * Index on lat, lon
     */
    public function saveLatLon($post_id, $post)
    {
        if ($post->post_type != 'monkeyman_geo') {
            return;
        }
        $lat = floatval(get_post_meta($post_id, 'lat', true));
        $lon = floatval(get_post_meta($post_id, 'lon', true));

        global $wpdb;
        $result = $wpdb->replace(
            $wpdb->prefix . 'monkeyman_geo',
            array(
                'post_id' => $post_id,
                'lat' => $lat,
                'lon' => $lon,
            ),
            array('%s', '%F', '%F')
        );
    }

    public function addAdminPages()
    {
        add_management_page( 'Quick location generator', 'Quick generator', 'edit_posts', __FILE__  . 'generator', array($this, 'doGeneratorPage'));
        add_management_page( 'Location test', 'Location test', 'edit_posts', __FILE__ . 'test', array($this, 'doTestPage'));

    }

    /**
     * Simple test page with a location and a distance
     */
    public function doTestPage()
    {
        if (!array_key_exists('search', $_REQUEST)) {
            $default_lat = ini_get('date.default_latitude');
            $default_lon = ini_get('date.default_longitude');

            echo <<<EOF
<form action="" method="post">
    <p>Center latitude: <input size="10" name="center_lat" value="{$default_lat}"/>
        <br/>Center longitude: <input size="10" name="center_lon" value="{$default_lon}"/>
        <br/>Max distance (km): <input size="5" name="max_distance" value="100"/></p>
    <p><input type="submit" name="search" value="Search!"/></p>
</form>
EOF;
            return;
        }
        $center_lon = floatval($_REQUEST['center_lon']);
        $center_lat = floatval($_REQUEST['center_lat']);
        $max_distance = floatval($_REQUEST['max_distance']);

        var_dump(self::getPostsUntilDistanceKm($center_lon, $center_lat, $max_distance));
    }

    /**
     * Get all posts that are closer than the given distance to the given location
     */
    public static function getPostsUntilDistanceKm($center_lon, $center_lat, $max_distance)
    {
        list($north_lat, $east_lon, $south_lat, $west_lon) = self::getBoundingBox($center_lat, $center_lon, $max_distance);

        $geo_posts = self::getPostsInBoundingBox($north_lat, $east_lon, $south_lat, $west_lon);

        $close_posts = array();
        foreach ($geo_posts as $geo_post) {
            $post_lat = floatval($geo_post->lat);
            $post_lon = floatval($geo_post->lon);
            $post_distance = self::calculateDistanceKm($center_lat, $center_lon, $post_lat, $post_lon);
            if ($post_distance < $max_distance) {
                $close_posts[$geo_post->post_id] = $post_distance;
            }
        }
        return $close_posts;
    }

    /**
     * Select all posts ids in a given bounding box
     */
    public static function getPostsInBoundingBox($north_lat, $east_lon, $south_lat, $west_lon)
    {
        global $wpdb;
        $sql = $wpdb->prepare('SELECT post_id, lat, lon FROM ' . $wpdb->prefix . 'monkeyman_geo WHERE lat < %F AND lat > %F AND lon < %F AND lon > %F', array($north_lat, $south_lat, $west_lon, $east_lon));
        return $wpdb->get_results($sql, OBJECT_K);
    }

    /* Geographical calculations: distance and bounding box */

    /**
     * Calculate the distance between two coordinates
     * http://stackoverflow.com/questions/365826/calculate-distance-between-2-gps-coordinates/1416950#1416950
     */
    public static function calculateDistanceKm($a_lat, $a_lon, $b_lat, $b_lon)
    {
        $d_lon = deg2rad($b_lon - $a_lon);
        $d_lat = deg2rad($b_lat - $a_lat);
        $a = pow(sin($d_lat/2.0), 2) + cos(deg2rad($a_lat)) * cos(deg2rad($b_lat)) * pow(sin($d_lon/2.0), 2);
        $c = 2 * atan2(sqrt($a), sqrt(1-$a));
        $d = 6367 * $c;

        return $d;
    }

    /**
     * Create a box around a given point that extends a certain distance in each direction
     * http://www.colorado.edu/geography/gcraft/warmup/aquifer/html/distance.html
     *
     * @todo: Mind the gap at 180 degrees!
     */
    public static function getBoundingBox($center_lat, $center_lon, $distance_km)
    {
        $one_lat_deg_in_km = 111.321543; // Fixed
        $one_lon_deg_in_km = cos(deg2rad($center_lat)) * 111.321543; // Depends on latitude

        $north_lat = $center_lat + ($distance_km / $one_lat_deg_in_km);
        $south_lat = $center_lat - ($distance_km / $one_lat_deg_in_km);

        $east_lon = $center_lon - ($distance_km / $one_lon_deg_in_km);
        $west_lon = $center_lon + ($distance_km / $one_lon_deg_in_km);

        return array($north_lat, $east_lon, $south_lat, $west_lon);
    }

    /* Below this it's not interesting anymore */

    /**
     * Generate some test data
     */
    public function doGeneratorPage()
    {
        if (!array_key_exists('generate', $_REQUEST)) {
            $default_lat = ini_get('date.default_latitude');
            $default_lon = ini_get('date.default_longitude');

            echo <<<EOF
<form action="" method="post">
    <p>Number of posts: <input size="5" name="post_count" value="10"/></p>
    <p>Center latitude: <input size="10" name="center_lat" value="{$default_lat}"/>
        <br/>Center longitude: <input size="10" name="center_lon" value="{$default_lon}"/>
        <br/>Max distance (km): <input size="5" name="max_distance" value="100"/></p>
    <p><input type="submit" name="generate" value="Generate!"/></p>
</form>
EOF;
            return;
        }
        $post_count = intval($_REQUEST['post_count']);
        $center_lon = floatval($_REQUEST['center_lon']);
        $center_lat = floatval($_REQUEST['center_lat']);
        $max_distance = floatval($_REQUEST['max_distance']);

        list($north_lat, $east_lon, $south_lat, $west_lon) = self::getBoundingBox($center_lat, $center_lon, $max_distance);


        add_action('save_post', array(&$this, 'setPostLatLon'), 5);
        $precision = 100000;
        for ($p = 0; $p < $post_count; $p++) {
            self::$currentRandomLat = mt_rand($south_lat * $precision, $north_lat * $precision) / $precision;
            self::$currentRandomLon = mt_rand($west_lon * $precision, $east_lon * $precision) / $precision;

            $location = sprintf('(%F, %F)', self::$currentRandomLat, self::$currentRandomLon);

            $post_data = array(
                'post_status' => 'publish',
                'post_type' => 'monkeyman_geo',
                'post_content' => 'Point at ' . $location,
                'post_title' => 'Point at ' . $location,
            );

            var_dump(wp_insert_post($post_data));
        }
    }

    public static $currentRandomLat = null;
    public static $currentRandomLon = null;

    /**
     * Because I didn't know how to save meta data with wp_insert_post,
     * I do it here
     */
    public function setPostLatLon($post_id)
    {
        add_post_meta($post_id, 'lat', self::$currentRandomLat);
        add_post_meta($post_id, 'lon', self::$currentRandomLon);
    }

    /**
     * Register a simple post type for us
     */
    public function registerPostType()
    {
        register_post_type(
            'monkeyman_geo',
            array(
                'label' => 'Geo Location',
                'labels' => array(
                    'name' => 'Geo Locations',
                    'singular_name' => 'Geo Location',
                    'add_new' => 'Add new',
                    'add_new_item' => 'Add new location',
                    'edit_item' => 'Edit location',
                    'new_item' => 'New location',
                    'view_item' => 'View location',
                    'search_items' => 'Search locations',
                    'not_found' => 'No locations found',
                    'not_found_in_trash' => 'No locations found in trash',
                    'parent_item_colon' => null,
                ),
                'description' => 'Geographical locations',
                'public' => true,
                'exclude_from_search' => false,
                'publicly_queryable' => true,
                'show_ui' => true,
                'menu_position' => null,
                'menu_icon' => null,
                'capability_type' => 'post',
                'capabilities' => array(),
                'hierarchical' => false,
                'supports' => array(
                    'title',
                    'editor',
                    'custom-fields',
                ),
                'register_meta_box_cb' => null,
                'taxonomies' => array(),
                'permalink_epmask' => EP_PERMALINK,
                'rewrite' => array(
                    'slug' => 'locations',
                ),
                'query_var' => true,
                'can_export' => true,
                'show_in_nav_menus' => true,
            )
        );
    }
}

$monkeyman_Geo_instance = new Monkeyman_Geo();

@ जान : जवाब के लिए धन्यवाद। क्या आपको लगता है कि आप इन पर अमल करते हुए कुछ वास्तविक कोड प्रदान कर सकते हैं?
माइकस्किंकल

@ माइक: यह एक दिलचस्प चुनौती थी, लेकिन यहां कुछ कोड हैं जिन्हें काम करना चाहिए।
जन फैब्री

@ जान फेब्री: कूल! जब मैं उस प्रोजेक्ट पर वापस जाऊंगा तो मैं इसे देखूंगा।
माइकस्किंकेल

1

मुझे इस पर पार्टी करने में देर हो रही है, लेकिन इस पर वापस देख रहे हैं, get_post_metaवास्तव में यहाँ समस्या है, बजाय SQL क्वेरी के जो आप उपयोग कर रहे हैं।

मुझे हाल ही में एक साइट पर एक समान जियो लुकअप करना था जो मैं चलाता हूं, और लाटा और लोन को स्टोर करने के लिए मेटा टेबल का उपयोग करने के बजाय (जिसे देखने के लिए आपको सबसे अच्छा दो जॉइन करने की आवश्यकता है और, यदि आप get_post_meta, दो अतिरिक्त डेटाबेस का उपयोग कर रहे हैं स्थान के अनुसार प्रश्न), मैंने एक स्थानिक रूप से अनुक्रमित ज्यामिति बिंदु डेटा प्रकार के साथ एक नई तालिका बनाई।

मेरी क्वेरी आपको बहुत पसंद है, MySQL के साथ बहुत भारी उठाने का काम किया (मैंने ट्रिगर कार्यों को छोड़ दिया और दो-आयामी स्थान के लिए सब कुछ सरल कर दिया, क्योंकि यह मेरे उद्देश्यों के लिए पर्याप्त था)

function nearby_property_listings( $number = 5 ) {
    global $client_location, $wpdb;

    //sanitize public inputs
    $lat = (float)$client_location['lat'];  
    $lon = (float)$client_location['lon']; 

    $sql = $wpdb->prepare( "SELECT *, ROUND( SQRT( ( ( ( Y(geolocation) - $lat) * 
                                                       ( Y(geolocation) - $lat) ) *
                                                         69.1 * 69.1) +
                                                  ( ( X(geolocation) - $lon ) * 
                                                       ( X(geolocation) - $lon ) * 
                                                         53 * 53 ) ) ) as distance
                            FROM {$wpdb->properties}
                            ORDER BY distance LIMIT %d", $number );

    return $wpdb->get_results( $sql );
}

जहाँ $ client_location सार्वजनिक जियो IP लुकअप सेवा द्वारा लौटाया गया मान है (मैंने geoio.com का उपयोग किया था, लेकिन कई समान हैं।)

यह देखने में अटपटा लग सकता है, लेकिन परीक्षण में, इसने लगातार .4 सेकेंड के अंदर 80,000-पंक्ति तालिका में से निकटतम 5 स्थानों को वापस कर दिया।

जब तक MySQL DISTANCE फ़ंक्शन को प्रस्तावित नहीं करता है, तब तक यह सबसे अच्छा तरीका है जैसे मैंने लोकेशन लुकअप को लागू करने के लिए पाया।

संपादित करें: इस विशेष तालिका के लिए तालिका संरचना को जोड़ना। इसकी संपत्ति लिस्टिंग का एक सेट है, इसलिए यह किसी अन्य उपयोग-केस के समान हो भी सकता है और नहीं भी।

CREATE TABLE IF NOT EXISTS `rh_properties` (
  `listingId` int(10) unsigned NOT NULL,
  `listingType` varchar(60) collate utf8_unicode_ci NOT NULL,
  `propertyType` varchar(60) collate utf8_unicode_ci NOT NULL,
  `status` varchar(20) collate utf8_unicode_ci NOT NULL,
  `street` varchar(64) collate utf8_unicode_ci NOT NULL,
  `city` varchar(24) collate utf8_unicode_ci NOT NULL,
  `state` varchar(5) collate utf8_unicode_ci NOT NULL,
  `zip` decimal(5,0) unsigned zerofill NOT NULL,
  `geolocation` point NOT NULL,
  `county` varchar(64) collate utf8_unicode_ci NOT NULL,
  `bedrooms` decimal(3,2) unsigned NOT NULL,
  `bathrooms` decimal(3,2) unsigned NOT NULL,
  `price` mediumint(8) unsigned NOT NULL,
  `image_url` varchar(255) collate utf8_unicode_ci NOT NULL,
  `description` mediumtext collate utf8_unicode_ci NOT NULL,
  `link` varchar(255) collate utf8_unicode_ci NOT NULL,
  PRIMARY KEY  (`listingId`),
  KEY `geolocation` (`geolocation`(25))
)

geolocationस्तंभ प्रयोजनों के लिए यहां प्रासंगिक केवल एक चीज है; इसमें x (lon), y (lat) निर्देशांक होते हैं जो मैं डेटाबेस में नए मानों को आयात करने पर पते से देखता हूं।


अनुवर्ती कार्रवाई के लिए धन्यवाद। मैंने वास्तव में एक तालिका को जोड़ने से बचने की कोशिश की, लेकिन एक तालिका को भी जोड़ना समाप्त कर दिया, हालांकि इसे विशिष्ट उपयोग के मामले से अधिक सामान्य बनाने की कोशिश की। इसके अलावा, मैंने POINT डेटा प्रकार का उपयोग नहीं किया क्योंकि मैं बेहतर मानक डेटा प्रकारों के साथ रहना चाहता था; MySQL के जियो एक्सटेंशन के लिए आरामदायक होने के लिए सीखने की एक अच्छी आवश्यकता है। उस ने कहा, क्या आप अपनी तालिका के लिए डीडीएल के साथ कृपया अपना जवाब अपडेट कर सकते हैं? मुझे लगता है कि यह भविष्य में इसे पढ़ने वाले अन्य लोगों के लिए शिक्षाप्रद होगा।
15

0

सभी संस्थाओं के बीच की दूरी की पूर्व-गणना करें। मैं इसे एक डेटाबेस टेबल में स्टोर करूंगा, जो कि इंडेक्स वैल्यूज की क्षमता के साथ खुद पर है।


यह रिकॉर्ड के व्यावहारिक रूप से अनंत संख्या है ...
माइकशिन्कल

Infinte? मैं यहाँ केवल n ^ 2 देखता हूं, जो कि infinte नहीं है। विशेष रूप से अधिक से अधिक प्रविष्टियों के साथ, precalcultaion अधिक से अधिक माना जाना चाहिए।
हकर्रे

व्यावहारिक रूप से अनंत। 7 दशमलव स्थानों की सटीकता पर Lat / Long दिया गया जो 6.41977E + 17 रिकॉर्ड देगा। हाँ, हमारे पास ऐसा बहुत नहीं है, लेकिन जो कुछ भी उचित होगा, उससे कहीं अधिक हमारे पास होगा।
माइकस्किंकल

अनंत एक अच्छी तरह से परिभाषित शब्द है, और इसमें विशेषण जोड़ने से ज्यादा बदलाव नहीं होता है। लेकिन मुझे पता है कि आपका क्या मतलब है, आपको लगता है कि यह गणना करना बहुत अधिक है। यदि आप समय के साथ धाराप्रवाह नए स्थानों की एक बड़ी मात्रा में नहीं जोड़ रहे हैं, तो यह पूर्व-गणना पृष्ठभूमि में आपके आवेदन से अलग चल रही नौकरी द्वारा चरण-दर-चरण किया जा सकता है। सटीक गणना की संख्या में परिवर्तन नहीं करता है। स्थानों की संख्या करता है। लेकिन शायद मैंने आपकी टिप्पणी के उस हिस्से को गलत समझा। उदाहरण के लिए 64 स्थानों का परिणाम 4 096 (या n * (n-1) के लिए 4 032) गणना और इसलिए रिकॉर्ड होगा।
हैकर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.