मैं एक वेक्टर को दूसरे के मूल्यों के आधार पर कैसे सॉर्ट करता हूं

Question

मेरे पास एक वेक्टर x है, जिसे मैं वेक्टर y में मूल्यों के क्रम के आधार पर क्रमबद्ध करना चाहूंगा। दो वैक्टर एक ही लंबाई के नहीं हैं।

x <- c(2, 2, 3, 4, 1, 4, 4, 3, 3)
y <- c(4, 2, 1, 3)

अपेक्षित परिणाम होगा:

[1] 4 4 4 2 2 1 3 3 3

Answer 1

यहाँ एक लाइनर है ...

y[sort(order(y)[x])]

[संपादित करें:] यह निम्नानुसार टूट जाता है:

order(y)             #We want to sort by y, so order() gives us the sorting order
order(y)[x]          #looks up the sorting order for each x
sort(order(y)[x])    #sorts by that order
y[sort(order(y)[x])] #converts orders back to numbers from orders

Comments

यह बहुत सफल है, लेकिन मुझे लगता है कि वहाँ क्या चल रहा है एक कठिन समय आ रहा है। क्या आप थोड़ा विस्तार कर सकते हैं?

— मैट पार्कर

यह सुंदर है और आर-निर्मित की एक अच्छी समझ को दर्शाता है। +1

— गोडके

सामान्य तौर पर कोई ऐसा करना चाहता है, भले ही y 1: लंबाई (y) का क्रमचय न हो। उस स्थिति में यह समाधान काम नहीं करता है, लेकिन नीचे gd047 का समाधान, x [क्रम (मिलान (x, y)))] करता है।

— राहुल सवाणी

मैं वास्तव में चकित हूं कि इसमें 40 उत्थान क्यों हैं। यह इतने सारे सरल बदलावों के लिए विफल रहता है xऔर y। x <- c(1,4,2); y <- c(1,2,4)उदाहरण के लिए।

— Thelatemail

@thelatemail मैं सहमत हूँ। पागलपन बंद करो और इस जवाब को नीचा दिखाओ!

— इयान फैलो

Answer 2

और इसका क्या

x[order(match(x,y))]

Comments

यह बहुत अच्छा है, स्वीकृत उत्तर IMHO से बेहतर है क्योंकि यह अधिक सामान्य है।

— fmark

मैं यह कहना चाहूंगा कि यह आधार GNU-R में होना चाहिए।

— भयावह-असफलता

X और y दोनों के लिए वर्ण वैक्टर का उपयोग करते समय इस उत्तर ने मेरे लिए अच्छा काम किया। स्वीकार किए जाते हैं जवाब में के रूप में एक अपघटन / मामूली विस्तार जोड़ना होगा अच्छा

— लीक से हटकर

Answer 3

आप xएक आदेशित कारक में बदल सकते हैं :

x.factor <- factor(x, levels = y, ordered=TRUE)
sort(x)
sort(x.factor)

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

Comments

यह सबसे अच्छा उत्तर होना चाहिए क्योंकि यह गैर पूर्णांक मामलों के लिए काम करेगा; या उस समय भी काम करते हैं जब थोड़े से बदलाव के साथ xछँटाई वाले वेक्टर में नहीं होते yहैं:x <- c(2, 2, 3, 4, 1, 4, 4, 3, 3, 6); y <- c(4, 2, 1, 3); as.numeric(as.character(sort(factor(x, unique(c(y, x))))))

— रॉआरआर 11'17

Answer 4

कैसा रहेगा?:

rep(y,table(x)[as.character(y)])

(इयान की शायद अभी भी बेहतर है)

Answer 5

मामले में आपको "y" पर आदेश प्राप्त करने की आवश्यकता है, भले ही वह संख्या या वर्ण हो:

x[order(ordered(x, levels = y))]
4 4 4 2 2 1 3 3 3

चरणों द्वारा:

a <- ordered(x, levels = y) # Create ordered factor from "x" upon order in "y".
[1] 2 2 3 4 1 4 4 3 3
Levels: 4 < 2 < 1 < 3

b <- order(a) # Define "x" order that match to order in "y".
[1] 4 6 7 1 2 5 3 8 9

x[b] # Reorder "x" according to order in "y".
[1] 4 4 4 2 2 1 3 3 3

Answer 6

[ संपादित करें: स्पष्ट रूप से इयान के पास सही दृष्टिकोण है, लेकिन मैं इसे पोस्टीरिटी के लिए छोड़ दूंगा।]

आप अपने y वेक्टर पर अनुक्रमणिका के बिना लूप के बिना ऐसा कर सकते हैं। एक वृद्धिशील संख्यात्मक मान को y में जोड़ें और उन्हें मर्ज करें:

y <- data.frame(index=1:length(y), x=y)
x <- data.frame(x=x)
x <- merge(x,y)
x <- x[order(x$index),"x"]
x
[1] 4 4 4 2 2 1 3 3 3

Answer 7

x <- c(2, 2, 3, 4, 1, 4, 4, 3, 3)
y <- c(4, 2, 1, 3)
for(i in y) { z <- c(z, rep(i, sum(x==i))) }

Z में परिणाम: 4 4 4 2 2 1 3 3 3

महत्वपूर्ण कदम:

1. for (i in y) - ब्याज के तत्वों पर लूप्स।

2. z <- c (z, ...) - बदले में प्रत्येक उपप्रकार को समेटता है

3. rep (i, sum (x == i)) - दोहराता है i (ब्याज का वर्तमान तत्व) sum (x == i) बार (हमने x में कितनी बार कितनी संख्या पाई)।

Answer 8

इसके अलावा, आप निम्न में sqldfसे किसी एक joinकार्य में इसका उपयोग और कर सकते हैं sql:

library(sqldf)
x <- data.frame(x = c(2, 2, 3, 4, 1, 4, 4, 3, 3))
y <- data.frame(y = c(4, 2, 1, 3))

result <- sqldf("SELECT x.x FROM y JOIN x on y.y = x.x")
ordered_x <- result[[1]]