मैं एक मेज है कि इस तरह दिखता है का उपयोग करता है:उपयुक्त डेटा संरचना पर्वतमाला
<22 23-27
8-10 1.3 1.8
11-13 2.2 2.8
14-16 3.2 3.8
और उस पर चला जाता है। इसलिए मैं इस तरह के मूल्य को देखना चाहता हूं:
lookup(11,25)
और इस मामले में 2.8 मामले में प्रतिक्रिया प्राप्त करें। इसके लिए उपयोग करने के लिए सबसे अच्छी डेटा संरचना क्या है? मेरे पास सीएसवी प्रारूप में डेटा है।
मैं इसे PHP में प्रोग्राम करना चाहता हूं।
धन्यवाद।
मैं निश्चित रूप से यह दावा करते हुए नहीं कर रहा हूँ यह सबसे अच्छा या सबसे कुशल डेटा संरचना है, लेकिन यह कैसे मैं एक दो आयामी पीएचपी सरणी कि बहुत बारीकी से अपने कच्चे डेटा जैसा दिखता है में अपने डेटा को मैप होता है:
$fp = fopen('data.csv', 'r');
$cols = fgetcsv($fp);
array_shift($cols); // remove empty first item
$data = array();
while ($row = fgetcsv($fp)) {
list($min, $max) = explode('-', $row[0]);
// TODO: Handle non-range values here (e.g. column header "<22")
$data["$min-$max"] = array();
for ($x = 0; $x < count($cols); $x++) {
$data["$min-$max"][$cols[$x]] = $row[$x + 1];
}
}
तब आप अपने lookup समारोह में कुछ पार्स तर्क जोड़ने की जरूरत चाहते हैं:
function lookup($row, $col) {
$return = null;
// Loop through all rows
foreach ($data as $row_name => $cols) {
list($min, $max) = explode('-', $row_name);
if ($min <= $row && $max >= $row) {
// If row matches, loop through columns
foreach ($cols as $col_name => $value) {
// TODO: Add support for "<22"
list($min, $max) = explode('-', $col_name);
if ($min <= $col && $max >= $col) {
$return = $value;
break;
}
}
break;
}
}
return $return;
}
किसी प्रकार की दो आयामी डेटा संरचना के बारे में कैसे।
X "coordinates" being <22, 23-27
Y "coordinates" being ...
एक दो आयामी ऐरे शायद इस उद्देश्य के लिए काम करेगा।
आपको श्रेणियों के लिए विशिष्ट एक्स और वाई मानों को मैप करने के लिए कुछ फ़ंक्शन की आवश्यकता होगी, लेकिन यह बहुत कठिन नहीं होना चाहिए।
सबसे आसान विकल्प: सरणियों, जहां प्रत्येक सरणी 5 तत्वों से युक्त है की सरणी बनाने के लिए: MINX, मैक्स, miny, Maxy, मूल्य, आपके मामले में यह होगा
$data = array(
array(8, 10, 0, 22, 1.3),
array(8, 10, 23, 27, 1.8),
array(11, 13, 0, 22, 2.2), etc
एक पाश है कि माध्यम से चला जाता लिखने एक छोटा सा डाटासेट इस तरीके से कार्य करेंगे, यदि आपका डाटासेट बड़ा है आप एक डेटाबेस का उपयोग पर विचार करना चाहिए साथ
function find($x, $y) {
foreach($data as $e) {
if($x <= $e[0] && $x >= $e[1] && $y <= $e[2] && $y >= $e[3])
return $e[4];
}
: हर तत्व और अपने तर्क के साथ मिनट & अधिकतम मान तुलना करती है।
डेटाबेस संरचना:
values
------
value
x_range_start
x_range_end
y_range_start
y_range_end
कोड:
function lookup(x, y) {
sql = "
SELECT * FROM values
WHERE
x >= x_range_start
AND
x <= x_range_end
AND
y >= y_range_start
AND
y <= y_range_end
"
/---/
}
आपका डाटा तो जैसे डेटाबेस के लिए नक्शे होगा:
<22 23-27
8-10 1.3 1.8
11-13 2.2 2.8
14-16 3.2 3.8
(value, x start, x end, y start, y end)
1.3, 0, 22, 8, 10
1.8, 23, 27, 8, 10
2.2, 0, 22, 11, 13
...
मूल रूप से तालिका में प्रत्येक मूल्य के लिए स्टोर x और y अक्ष आरंभ और समाप्ति संख्या।
मैं एक "हैश" फ़ंक्शन के साथ 2 आयामी सरणी के आंशिक हूं जो तालिका में विशिष्ट पते में श्रेणियों को मानचित्र करता है।
int xhash(int);
int yhash(int);
कि आपके सरणी में मूल तर्क ले और अनुक्रमित में उन्हें बदलने:
0 1
0 1.3 1.8
1 2.2 2.8
2 3.2 3.8
तो फिर तुम दो कार्यों लिखना होगा:
तो आपके मौलिक डेटा संरचना एक 2 आयामी सरणी होगा । तो xhash रूपांतरण करता है:
8-10 0
11-13 1
14-16 2
अंत में, आपका लुकअप ऑपरेशन बन जाता है।
function lookup($x, $y)
{
$xIndex = xhash($x);
$yIndex = yhash($y);
// Handle invalid indices!
return $data[$xIndex][$yIndex];
}
ठीक है, अन्य सभी उत्तर 2 डी arrays का उपयोग करते हैं, जिसका अर्थ यह है कि इसे पुनः प्राप्त करने के लिए 2 डी लूप का उपयोग करना है। जो, यदि आपकी श्रेणियां आयु सीमाएं या कुछ समान हैं, तो सीमित हो सकती है (केवल इतनी सारी आयु सीमाएं हैं!), और कोई मुद्दा नहीं (कुछ सौ पुनरावृत्तियों क्या है?)। यदि आपकी श्रेणियों को भारी संख्या में स्केल करने की उम्मीद है, तो हैश मानचित्र पर एक खेल आपकी सबसे अच्छी शर्त हो सकती है। तो, आप एक हैशिंग फ़ंक्शन बनाते हैं जो किसी भी संख्या को प्रासंगिक श्रेणी में बदल देता है, फिर आप लूप के बजाय प्रत्यक्ष लुकअप करते हैं। यह ओ (एन^2) के बजाय ओ (1) पहुंच होगी।
तो आपका हैश फ़ंक्शन इस प्रकार हो सकता है: फ़ंक्शन हैश (एन) {if (n < 22) 1 वापसी; अगर (एन < 25) वापसी 2; वापसी -1; }, और फिर आप अपने हैंश मानों (1, 2, आदि) के संदर्भ में अपनी श्रेणियां निर्दिष्ट कर सकते हैं, और उसके बाद केवल $ डेटा [हैश (11)] [हैश (25)]
मुझे लगता है कि यह होगा उत्तम। शायद यह उल्लेख किया जाना चाहिए कि इसके लिए दक्षता जरूरी नहीं है, इसलिए यह कोई चिंता नहीं है। विस्तृत कोड के लिए धन्यवाद! – Jon