यह जाँचने का कोई तेज़ तरीका है कि सूची में सूची समतुल्य है या नहीं?

9

यहां मेरे पास 1:7चार अलग-अलग विभाजनों के लिए पूर्णांक हैं , अर्थात, {1}, {2,3,4}, {5,6}, और {7} और उन विभाजनों को एक सूची में लिखा जाता है, अर्थात list(1,c(2,3,4),c(5,6),7)। मैं विभाजनों को सेट के रूप में मानता हूं, जैसे कि एक विभाजन के भीतर तत्वों के विभिन्न क्रमांकन को एक ही के रूप में मान्यता दी जानी चाहिए। उदाहरण के लिए, list(1,c(2,3,4),c(5,6),7)और list(7,1,c(2,3,4),c(6,5))समतुल्य हैं।

ध्यान दें, सूची में तत्वों के लिए कोई पुनरावृत्ति नहीं है , उदाहरण के लिए, नहीं list(c(1,2),c(2,1),c(1,2)), क्योंकि यह समस्या पूरे सेट पर विशेष विभाजन पर चर्चा कर रही है।

मैंने lstनीचे दिए गए सूची में कुछ अलग क्रमांकन सूचीबद्ध किए हैं

lst <- list(list(1,c(2,3,4),c(5,6),7),
            list(c(2,3,4),1,7,c(5,6)),
            list(1,c(2,3,4),7,c(6,5)),
            list(7,1,c(3,2,4),c(5,6)))

और मैं क्या करना चाहता हूँ सत्यापित करने के लिए सभी क्रमपरिवर्तन समतुल्य हैं। यदि हाँ, तो हमें परिणाम मिलता है TRUE।

क्या मैं अब तक किया था प्रत्येक विभाजन के भीतर तत्वों सॉर्ट करने के लिए है, और उपयोग setdiff()के साथ interset()और union()यह निर्णय करना (मेरे कोड नीचे देखें)

s <- Map(function(v) Map(sort,v),lst)
equivalent <- length(setdiff(Reduce(union,s),Reduce(intersect,s),))==0

हालांकि, मुझे लगता है कि जब भी विभाजन का आकार बढ़ेगा तो यह विधि धीमी होगी। क्या इसे बनाने के लिए कोई तेज़ तरीका है? अग्रिम में सराहना की!

  • कुछ परीक्षण मामले (छोटे आकार के डेटा)
# should return `TRUE`
lst1 <- list(list(1,c(2,3,4),c(5,6)),
            list(c(2,3,4),1,c(5,6)),
            list(1,c(2,3,4),c(6,5)))

# should return `TRUE`
lst2 <- list(list(1:2, 3:4), list(3:4, 1:2))

# should return `FALSE`
lst3 <- list(list(1,c(2,3,4),c(5,6)), list(c(2,3,4),1,c(5,6)), list(1,c(2,3,5),c(6,4)))
r  algorithm  list  performance 
— ThomasIsCoding
स्रोत
1
मुझे लगता है कि आप कई Mapकॉल से बच सकते हैं
— akrun
1
मैं आपके प्रश्न में कुछ और परीक्षण मामलों को जोड़ने का सुझाव दूंगा, एक समान आकार के विभाजन के साथ, lst_equal = list(list(1:2, 3:4), list(3:4, 1:2))और एक वह भी जहां परिणाम होना चाहिए FALSE, हो सकता हैlst_false <- list(list(1,c(2,3,4),c(5,6)), list(c(2,3,4),1,c(5,6)), list(1,c(2,3,5),c(6,4)))
— ग्रेगर थॉमस
3
मैं दृढ़ता से कई छोटे उदाहरण रखने की सलाह दूंगा - जिनमें कुछ अपेक्षित परिणाम है FALSE। इस तरह, जब एक उत्तर कुछ पर काम करता है, लेकिन सभी नहीं, मामलों का परीक्षण करते हैं, तो इसका निदान करना आसान है। जब केवल एक ही उदाहरण होता है, तो आप परीक्षा परिणामों में बारीकियों को खो देते हैं। पहले से ही उन लोगों के तहत मौजूदा उदाहरणों को बदलने के बजाय नए उदाहरणों को जोड़ना अच्छा है।
— ग्रेगर थॉमस
1
मैं एक टिप्पणी जोड़ना चाहता हूं जो आपके विवरण से मुझे लगता है कि आपको परिणाम TRUE होने की उम्मीद है, आप इसे सत्यापित कर रहे हैं। यदि यह मामला नहीं था (उदाहरण के लिए, यदि आपको लगता है कि आपको महत्वपूर्ण संख्या में FALSEs मिलेंगे), और विशेष रूप से यदि लंबाई lstसंभवतः लंबी है, तो आप अन्य तरीकों से दक्षता हासिल कर सकते हैं। उदाहरण के लिए, पहला चेक जो length(unique(lengths(lst))) == 1बहुत जल्दी वापस आ जाएगा FALSEयदि किसी भी आंतरिक सूची में तत्वों की गलत संख्या है ...
— ग्रेगर थॉमस
1
यदि वह पास हो जाता है, तो आप lstतुलना lst[[i]]करने के बजाय एक आइटम को एक बार में जाना चाह सकते हैं lst[[1]], और इस तरह से आप सभी तुलना करने के बजाय एक बेमेल खोज सकते हैं। यदि lstलंबे और FALSEएस सामान्य हैं, तो यह एक बड़ी दक्षता हासिल कर सकता है, लेकिन शायद इसके लायक नहीं है।
— ग्रेगर थॉमस

जवाबों:

6

के बारे में Rऔर किसी भी प्रकार की एक पोस्ट उपवास केसमाधान की विशेषता के बिना पूरा नहीं होता हैrcpp।

दक्षता बढ़ाने के लिए, सही डेटा संरचना को चुनना अत्यंत महत्वपूर्ण होगा। हमारी डेटा संरचना को अनूठे मूल्यों को संग्रहीत करने की आवश्यकता है और इसके साथ ही तेज इंसर्ट / एक्सेस भी है। यह वही है जो std :: unordered_set का प्रतीक है। हमें केवल यह निर्धारित करने की आवश्यकता है कि हम प्रत्येक vectorअनियंत्रित की विशिष्ट पहचान कैसे कर सकते हैं integers।

अंकगणित के मौलिक सिद्धांत को दर्ज करें

एफटीए कहता है कि हर संख्या को विशिष्ट रूप से प्रतिनिधित्व किया जा सकता है ( कारकों के क्रम तक) को प्रिम्स नंबरों के उत्पाद द्वारा।

यहां एक उदाहरण प्रदर्शित किया गया है कि कैसे हम एफटीए का उपयोग जल्दी से समझने के लिए कर सकते हैं यदि दो वैक्टर ऑर्डर करने के लिए बराबर हैं (एनबी Pनीचे primes संख्याओं की एक सूची है ... (2, 3, 5, 7, 11, etc.):

                   Maps to                    Maps to              product
vec1 = (1, 2, 7)    -->>    P[1], P[2], P[7]   --->>   2,  3, 17     -->>   102
vec2 = (7, 3, 1)    -->>    P[7], P[3], P[1]   --->>  17,  5,  2     -->>   170
vec3 = (2, 7, 1)    -->>    P[2], P[7], P[1]   --->>   3, 17,  2     -->>   102

इससे, हम उस vec1और vec3सही रूप से एक ही नंबर पर vec2मैप करते हैं , जबकि एक अलग मूल्य पर मैप किया जाता है।

चूंकि हमारे वास्तविक वैक्टर में 1000 से कम सौ पूर्णांक हो सकते हैं, इसलिए एफटीए को लागू करने से बड़ी संख्या में उत्पादन होगा। हम लघुगणक के उत्पाद नियम का लाभ उठाकर इसे प्राप्त कर सकते हैं:

log b (xy) = log b (x) + log b (y)

इसके निपटान में, हम बहुत बड़ी संख्या के उदाहरणों से निपटने में सक्षम होंगे (यह बहुत बड़े उदाहरणों पर बिगड़ना शुरू होता है)।

सबसे पहले, हमें एक साधारण अभाज्य संख्या जनरेटर की आवश्यकता है (NB हम वास्तव में प्रत्येक अभाज्य संख्या का लॉग जनरेट कर रहे हैं)।

#include <Rcpp.h>
using namespace Rcpp;

// [[Rcpp::plugins(cpp11)]]

void getNPrimes(std::vector<double> &logPrimes) {

    const int n = logPrimes.size();
    const int limit = static_cast<int>(2.0 * static_cast<double>(n) * std::log(n));
    std::vector<bool> sieve(limit + 1, true);

    int lastP = 3;
    const int fsqr = std::sqrt(static_cast<double>(limit));

    while (lastP <= fsqr) {
        for (int j = lastP * lastP; j <= limit; j += 2 * lastP)
            sieve[j] = false;

        int ind = 2;

        for (int k = lastP + 2; !sieve[k]; k += 2)
            ind += 2;

        lastP += ind;
    }

    logPrimes[0] = std::log(2.0);

    for (int i = 3, j = 1; i <= limit && j < n; i += 2)
        if (sieve[i])
            logPrimes[j++] = std::log(static_cast<double>(i));
}

और यहाँ मुख्य कार्यान्वयन है:

// [[Rcpp::export]]
bool f_Rcpp_Hash(List x) {

    List tempLst = x[0];
    const int n = tempLst.length();
    int myMax = 0;

    // Find the max so we know how many primes to generate
    for (int i = 0; i < n; ++i) {
        IntegerVector v = tempLst[i];
        const int tempMax = *std::max_element(v.cbegin(), v.cend());

        if (tempMax > myMax)
            myMax = tempMax;
    }

    std::vector<double> logPrimes(myMax + 1, 0.0);
    getNPrimes(logPrimes);
    double sumMax = 0.0;

    for (int i = 0; i < n; ++i) {
        IntegerVector v = tempLst[i];
        double mySum = 0.0;

        for (auto j: v)
            mySum += logPrimes[j];

        if (mySum > sumMax)
            sumMax = mySum;
    }

    // Since all of the sums will be double values and we want to
    // ensure that they are compared with scrutiny, we multiply
    // each sum by a very large integer to bring the decimals to
    // the right of the zero and then convert them to an integer.
    // E.g. Using the example above v1 = (1, 2, 7) & v2 = (7, 3, 1)
    //              
    //    sum of log of primes for v1 = log(2) + log(3) + log(17)
    //                               ~= 4.62497281328427
    //
    //    sum of log of primes for v2 = log(17) + log(5) + log(2)
    //                               ~= 5.13579843705026
    //    
    //    multiplier = floor(.Machine$integer.max / 5.13579843705026)
    //    [1] 418140173
    //    
    // Now, we multiply each sum and convert to an integer
    //    
    //    as.integer(4.62497281328427 * 418140173)
    //    [1] 1933886932    <<--   This is the key for v1
    //
    //    as.integer(5.13579843705026 * 418140173)
    //    [1] 2147483646    <<--   This is the key for v2

    const uint64_t multiplier = std::numeric_limits<int>::max() / sumMax;
    std::unordered_set<uint64_t> canon;
    canon.reserve(n);

    for (int i = 0; i < n; ++i) {
        IntegerVector v = tempLst[i];
        double mySum = 0.0;

        for (auto j: v)
            mySum += logPrimes[j];

        canon.insert(static_cast<uint64_t>(multiplier * mySum));
    }

    const auto myEnd = canon.end();

    for (auto it = x.begin() + 1; it != x.end(); ++it) {
        List tempLst = *it;

        if (tempLst.length() != n)
            return false;

        for (int j = 0; j < n; ++j) {
            IntegerVector v = tempLst[j];
            double mySum = 0.0;

            for (auto k: v)
                mySum += logPrimes[k];

            const uint64_t key = static_cast<uint64_t>(multiplier * mySum);

            if (canon.find(key) == myEnd)
                return false;
        }
    }

    return true;
}

यहाँ परिणाम जब lst1, lst2, lst3, & lst (the large one)@GKi द्वारा दिए गए हैं।

f_Rcpp_Hash(lst)
[1] TRUE

f_Rcpp_Hash(lst1)
[1] TRUE

f_Rcpp_Hash(lst2)
[1] FALSE

f_Rcpp_Hash(lst3)
[1] FALSE

और यहां कुछ मानदंड unitsनिर्धारित पैरामीटर के साथ हैं relative।

microbenchmark(check = 'equal', times = 10
               , unit = "relative"
               , f_ThomsIsCoding(lst3)
               , f_chinsoon12(lst3)
               , f_GKi_6a(lst3)
               , f_GKi_6b(lst3)
               , f_Rcpp_Hash(lst3))
Unit: relative
                 expr       min        lq      mean    median        uq       max neval
f_ThomsIsCoding(lst3) 84.882393 63.541468 55.741646 57.894564 56.732118 33.142979    10
   f_chinsoon12(lst3) 31.984571 24.320220 22.148787 22.393368 23.599284 15.211029    10
       f_GKi_6a(lst3)  7.207269  5.978577  5.431342  5.761809  5.852944  3.439283    10
       f_GKi_6b(lst3)  7.399280  5.751190  6.350720  5.484894  5.893290  8.035091    10
    f_Rcpp_Hash(lst3)  1.000000  1.000000  1.000000  1.000000  1.000000  1.000000    10


microbenchmark(check = 'equal', times = 10
               , unit = "relative"
               , f_ThomsIsCoding(lst)
               , f_chinsoon12(lst)
               , f_GKi_6a(lst)
               , f_GKi_6b(lst)
               , f_Rcpp_Hash(lst))
Unit: relative
                expr        min         lq       mean     median        uq       max neval
f_ThomsIsCoding(lst) 199.776328 202.318938 142.909407 209.422530 91.753335 85.090838    10
   f_chinsoon12(lst)   9.542780   8.983248   6.755171   9.766027  4.903246  3.834358    10
       f_GKi_6a(lst)   3.169508   3.158366   2.555443   3.731292  1.902140  1.649982    10
       f_GKi_6b(lst)   2.992992   2.943981   2.019393   3.046393  1.315166  1.069585    10
    f_Rcpp_Hash(lst)   1.000000   1.000000   1.000000   1.000000  1.000000  1.000000    10

बड़े उदाहरण पर सबसे तेज़ समाधान की तुलना में लगभग 3x तेज ।

इसका क्या मतलब है?

मेरे लिए, यह परिणाम base R@GKi, @ chinsoon12, @Gregor, @ThomasIsCoding, और अधिक द्वारा प्रदर्शित सौंदर्य और दक्षता के लिए संस्करणों को बोलता है । हमने C++एक मध्यम गति प्राप्त करने के लिए बहुत विशिष्ट की लगभग 100 लाइनें लिखीं । उचित होने के लिए, base Rसमाधान ज्यादातर संकलित कोड को कॉल करते हैं और हैश तालिकाओं के उपयोग को समाप्त करते हैं जैसा कि हमने ऊपर किया था।

— जोसेफ वुड
स्रोत
1
@ThomasIsCoding, मैं सम्मानित महसूस कर रहा हूँ कि आपने मेरा उत्तर चुना है, लेकिन मेरा मानना ​​है कि अन्य उत्तर बेहतर हैं।
— जोसेफ वुड
1
आपके योगदान के लिए बहुत-बहुत धन्यवाद! आपका काम बेहतरीन है!
— थॉमसआई कोडिंग
5

छँटाई के बाद आप उपयोग कर सकते हैं duplicatedऔर all।

s <- lapply(lst, function(x) lapply(x, sort)) #Sort vectors
s <- lapply(s, function(x) x[order(vapply(x, "[", 1, 1))]) #Sort lists
all(duplicated(s)[-1]) #Test if there are all identical
#length(unique(s)) == 1 #Alternative way to test if all are identical

वैकल्पिक: एक लूप में क्रमबद्ध करें

s <- lapply(lst, function(x) {
  tt <- lapply(x, sort)
  tt[order(vapply(tt, "[", 1, 1))]
})
all(duplicated(s)[-1])

वैकल्पिक: लूप के दौरान क्रमबद्ध करें और जल्दी बाहर निकलने की अनुमति दें

s <- lapply(lst[[1]], sort)
s <- s[order(vapply(s, "[", 1, 1))]
tt  <- TRUE
for(i in seq(lst)[-1]) {
  x <- lapply(lst[[i]], sort)
  x <- x[order(vapply(x, "[", 1, 1))]
  if(!identical(s, x)) {
    tt  <- FALSE
    break;
  }
}
tt

या उपयोग कर रहा है setequal

s <- lapply(lst[[1]], sort)
tt  <- TRUE
for(i in seq(lst)[-1]) {
  x <- lapply(lst[[i]], sort)
  if(!setequal(s, x)) {
    tt  <- FALSE
    break;
  }
}
tt

या वेक्टर के साथ सूची का आदान-प्रदान करने के लिए @ chinsoon12 से विचार में थोड़ा सुधार !

s <- lst[[1]][order(vapply(lst[[1]], min, 1))]
s <- rep(seq_along(s), lengths(s))[order(unlist(s))]
tt <- TRUE
for(i in seq(lst)[-1]) {
  x <- lst[[i]][order(vapply(lst[[i]], min, 1))]
  x <- rep(seq_along(x), lengths(x))[order(unlist(x))]
  if(!identical(s, x)) {tt <- FALSE; break;}
}
tt

या दूसरे से बचें order

s <- lst[[1]][order(vapply(lst[[1]], min, 1))]
s <- rep(seq_along(s), lengths(s))[order(unlist(s))]
y <- s
tt <- TRUE
for(i in seq(lst)[-1]) {
  x <- lst[[i]][order(vapply(lst[[i]], min, 1))]
  y <- y[0]
  y[unlist(x)] <- rep(seq_along(x), lengths(x))
  if(!identical(s, y)) {tt <- FALSE; break;}
}
tt

या के orderसाथ विनिमयmatch (या fmatch) के

x <- lst[[1]]
s <- "[<-"(integer(),unlist(x),rep(seq_along(x), lengths(x)))
s <- match(s, unique(s))
tt <- TRUE
for(i in seq(lst)[-1]) {
  x <- lst[[i]]
  y <- "[<-"(integer(),unlist(x),rep(seq_along(x), lengths(x)))
  y <- match(y, unique(y))
  if(!identical(s, y)) {tt <- FALSE; break;}
}
tt

या जल्दी बाहर निकलने के बिना।

s <- lapply(lst, function(x) {
  y <- "[<-"(integer(),unlist(x),rep(seq_along(x), lengths(x)))
  match(y, unique(y))
})
all(duplicated(s)[-1])

या C ++ में लिखा है

sourceCpp(code = "#include <Rcpp.h>
#include <vector>
using namespace Rcpp;
// [[Rcpp::plugins(cpp11)]]
// [[Rcpp::export]]
bool f_GKi_6_Rcpp(const List &x) {
  const List &x0 = x[0];
  const unsigned int n = x0.length();
  unsigned int nn = 0;
  for (List const &i : x0) {nn += i.length();}
  std::vector<int> s(nn);
  for (unsigned int i=0; i<n; ++i) {
    const IntegerVector &v = x0[i];
    for (int const &j : v) {
      if(j > nn) return false;
      s[j-1] = i;
    }
  }
  {
    std::vector<int> lup(n, -1);
    int j = 0;
    for(int &i : s) {
      if(lup[i] < 0) {lup[i] = j++;}
      i = lup[i];
    }
  }
  for (List const &i : x) {
    if(i.length() != n) return false;
    std::vector<int> sx(nn);
    for(unsigned int j=0; j<n; ++j) {
      const IntegerVector &v = i[j];
      for (int const &k : v) {
        if(k > nn) return false;
        sx[k-1] = j;
      }
    }
    {
      std::vector<int> lup(n, -1);
      int j = 0;
      for(int &i : sx) {
        int &lupp = lup[i];
        if(lupp == -1) {lupp = j; i = j++;
        } else {i = lupp;}
      }
    }
    if(s!=sx) return false;
  }
  return true;
}
")

उत्तर सुधारने के लिए संकेत के लिए @Gregor को धन्यवाद!

— GKI
स्रोत
मुझे नहीं लगता कि समान आकार के विभाजन होने पर यह काम करेगा,, लेकिन असमान आकार के विभाजन होने पर मेरा तेजी से होना चाहिए। उदाहरण के लिए, lst <- list(list(1,c(2,3,4),c(5,6),7), list(c(2,3,4),1,7,c(5,6)), list(1,c(2,3,4),7,c(6,5)), list(7,1,c(3,2,4),c(5,6)))के रूप में निर्णय लिया जाएगाFALSE
— ThomasIsCoding
1
@Gregor द्वारा छाँटने के लिए टिप के लिए धन्यवाद min!
— GKi
अच्छा लग रहा है! मैं यह देखने के लिए थोड़ा इंतजार करूंगा कि क्या कोई और तेज समाधान है।
— थॉमसआईसकोडिंग
तेज़ समाधान प्राप्त करने के लिए आपके डेटासेट के वास्तविक आयाम क्या हैं?
— chinsoon12
मैंने कार्यक्षमता देखने के लिए प्रदर्शन बेंचमार्क जोड़ा (मेरी नई संपादित पोस्ट देखें)। आपका समाधान खदान से भी तेज है, खासकर दो-चरण वाला। मैं तब तक इंतजार करना चाहता हूं जब तक कि कोई सुधार बड़े सुधार के साथ प्रकट न हो, अन्यथा आपका सबसे अच्छा माना जाएगा। फिर से धन्यवाद!
— थॉमसआईकोडिंग 5
4

प्रदर्शन:

library(microbenchmark)

microbenchmark(check = 'equal', times=10
  , f_ThomsIsCoding(lst1)
  , f_chinsoon12(lst1)
  , f_GKi_6a(lst1)
  , f_GKi_6b(lst1)
  , f_GKi_6_Rcpp(lst1)
  , f_Rcpp_Hash(lst1))
#Unit: microseconds
#                  expr        min         lq        mean     median         uq        max neval
# f_ThomsIsCoding(lst1) 161187.790 162453.520 167107.5739 167899.471 169441.028 174746.156    10
#    f_chinsoon12(lst1)  64380.792  64938.528  66983.9449  67357.924  68487.438  69201.032    10
#        f_GKi_6a(lst1)   8833.595   9201.744  10377.5844   9407.864  12145.926  14662.022    10
#        f_GKi_6b(lst1)   8815.592   8913.950   9877.4948   9112.924  10941.261  12553.845    10
#    f_GKi_6_Rcpp(lst1)    394.754    426.489    539.1494    439.644    451.375   1327.885    10
#     f_Rcpp_Hash(lst1)    327.665    374.409    499.4080    398.101    495.034   1198.674    10

microbenchmark(check = 'equal', times=10
  , f_ThomsIsCoding(lst2)
  , f_chinsoon12(lst2)
  , f_GKi_6a(lst2)
  , f_GKi_6b(lst2)
  , f_GKi_6_Rcpp(lst2)
  , f_Rcpp_Hash(lst2))
#Unit: microseconds
#                  expr       min        lq        mean      median         uq        max neval
# f_ThomsIsCoding(lst2) 93808.603 99663.651 103358.2039 104676.1600 107124.879 107485.696    10
#    f_chinsoon12(lst2)   131.320   147.192    192.5354    188.1935    205.053    337.062    10
#        f_GKi_6a(lst2)  8630.970  9554.279  10681.9510   9753.2670  11970.377  13489.243    10
#        f_GKi_6b(lst2)    39.736    47.916     61.3929     52.7755     63.026    110.808    10
#    f_GKi_6_Rcpp(lst2)    43.017    51.022     72.8736     76.3465     86.527    116.060    10
#     f_Rcpp_Hash(lst2)     3.667     4.237     20.5887     16.3000     18.031     96.728    10

microbenchmark(check = 'equal', times=10
  , f_ThomsIsCoding(lst3)
  , f_chinsoon12(lst3)
  , f_GKi_6a(lst3)
  , f_GKi_6b(lst3)
  , f_GKi_6_Rcpp(lst3)
  , f_Rcpp_Hash(lst3))
#Unit: microseconds
#                  expr        min         lq        mean      median         uq        max neval
# f_ThomsIsCoding(lst3) 157660.501 166914.782 167067.2512 167204.9065 168055.941 177153.694    10
#    f_chinsoon12(lst3)    139.157    181.019    183.9257    188.0950    198.249    211.860    10
#        f_GKi_6a(lst3)   9484.496   9617.471  10709.3950  10056.1865  11812.037  12830.560    10
#        f_GKi_6b(lst3)     33.583     36.338     47.1577     42.6540     63.469     66.640    10
#    f_GKi_6_Rcpp(lst3)     60.010     60.455     89.4963     94.7220    104.271    121.431    10
#     f_Rcpp_Hash(lst3)      4.404      5.518      9.9811      6.5115     17.396     20.090    10

microbenchmark(check = 'equal', times=10
  , f_ThomsIsCoding(lst4)
  , f_chinsoon12(lst4)
  , f_GKi_6a(lst4)
  , f_GKi_6b(lst4)
  , f_GKi_6_Rcpp(lst4)
  , f_Rcpp_Hash(lst4))
#Unit: milliseconds
#                  expr         min          lq       mean      median          uq        max neval
# f_ThomsIsCoding(lst4) 1874.129146 1937.643431 2012.99077 2002.460746 2134.072981 2187.46886    10
#    f_chinsoon12(lst4)   69.949917   74.393779   80.25362   76.595763   87.116571  100.57917    10
#        f_GKi_6a(lst4)   23.259178   23.328548   27.62690   28.856612   30.675259   32.57509    10
#        f_GKi_6b(lst4)   22.200969   22.326122   24.20769   23.023687   23.619360   31.74266    10
#    f_GKi_6_Rcpp(lst4)    8.062451    8.228526   10.30559    8.363314   13.425531   13.80677    10
#     f_Rcpp_Hash(lst4)    6.551370    6.586025    7.22958    6.724232    6.809745   11.97631    10

पुस्तकालय:

system.time(install.packages("Rcpp"))
#       User      System verstrichen 
#     27.576       1.147      29.396 

system.time(library(Rcpp))
#       User      System verstrichen 
#      0.070       0.000       0.071

कार्य:

system.time({f_ThomsIsCoding <- function(lst) {
  s <- Map(function(v) Map(sort,v),lst)
  length(setdiff(Reduce(union,s),Reduce(intersect,s)))==0
}})
#       User      System verstrichen 
#          0           0           0 

#like GKi's solution to stop early when diff is detected
system.time({f_chinsoon12  <- function(lst) {
    x <- lst[[1L]]
    y <- x[order(lengths(x), sapply(x, min))]
    a <- rep(seq_along(y), lengths(y))[order(unlist(y))]
    for(x in lst[-1L]) {
        y <- x[order(lengths(x), sapply(x, min))]
        a2 <- rep(seq_along(y), lengths(y))[order(unlist(y))]
        if(!identical(a, a2)) {
            return(FALSE)
        }
    }
    TRUE
}})
#       User      System verstrichen 
#          0           0           0 

system.time({f_GKi_6a <- function(lst) {
  all(duplicated(lapply(lst, function(x) {
    y <- "[<-"(integer(),unlist(x),rep(seq_along(x), lengths(x)))
    match(y, unique(y))
  }))[-1])
}})
#      User      System verstrichen 
#          0           0           0 

system.time({f_GKi_6b <- function(lst) {
  x <- lst[[1]]
  s <- "[<-"(integer(),unlist(x),rep(seq_along(x), lengths(x)))
  s <- match(s, unique(s))
  for(i in seq(lst)[-1]) {
    x <- lst[[i]]
    y <- "[<-"(integer(),unlist(x),rep(seq_along(x), lengths(x)))
    y <- match(y, unique(y))
    if(!identical(s, y)) return(FALSE)
  }
  TRUE
}})
#       User      System verstrichen 
#          0           0           0 

system.time({sourceCpp(code = "#include <Rcpp.h>
#include <vector>
using namespace Rcpp;
// [[Rcpp::plugins(cpp11)]]
// [[Rcpp::export]]
bool f_GKi_6_Rcpp(const List &x) {
  const List &x0 = x[0];
  const unsigned int n = x0.length();
  unsigned int nn = 0;
  for (List const &i : x0) {nn += i.length();}
  std::vector<int> s(nn);
  for (unsigned int i=0; i<n; ++i) {
    const IntegerVector &v = x0[i];
    for (int const &j : v) {
      if(j > nn) return false;
      s[j-1] = i;
    }
  }
  {
    std::vector<int> lup(n, -1);
    int j = 0;
    for(int &i : s) {
      if(lup[i] < 0) {lup[i] = j++;}
      i = lup[i];
    }
  }
  for (List const &i : x) {
    if(i.length() != n) return false;
    std::vector<int> sx(nn);
    for(unsigned int j=0; j<n; ++j) {
      const IntegerVector &v = i[j];
      for (int const &k : v) {
        if(k > nn) return false;
        sx[k-1] = j;
      }
    }
    {
      std::vector<int> lup(n, -1);
      int j = 0;
      for(int &i : sx) {
        int &lupp = lup[i];
        if(lupp == -1) {lupp = j; i = j++;
        } else {i = lupp;}
      }
    }
    if(s!=sx) return false;
  }
  return true;
}
")})
#       User      System verstrichen 
#      3.265       0.217       3.481 

system.time({sourceCpp(code = "#include <Rcpp.h>
using namespace Rcpp;

// [[Rcpp::plugins(cpp11)]]

void getNPrimes(std::vector<double> &logPrimes) {
    const int n = logPrimes.size();
    const int limit = static_cast<int>(2.0 * static_cast<double>(n) * std::log(n));
    std::vector<bool> sieve(limit + 1, true);
    int lastP = 3;
    const int fsqr = std::sqrt(static_cast<double>(limit));

    while (lastP <= fsqr) {
        for (int j = lastP * lastP; j <= limit; j += 2 * lastP)
            sieve[j] = false;
        int ind = 2;
        for (int k = lastP + 2; !sieve[k]; k += 2)
            ind += 2;
        lastP += ind;
    }
    logPrimes[0] = std::log(2.0);
    for (int i = 3, j = 1; i <= limit && j < n; i += 2)
        if (sieve[i])
            logPrimes[j++] = std::log(static_cast<double>(i));
}

// [[Rcpp::export]]
bool f_Rcpp_Hash(List x) {
    List tempLst = x[0];
    const int n = tempLst.length();
    int myMax = 0;
    // Find the max so we know how many primes to generate
    for (int i = 0; i < n; ++i) {
        IntegerVector v = tempLst[i];
        const int tempMax = *std::max_element(v.cbegin(), v.cend());
        if (tempMax > myMax)
            myMax = tempMax;
    }
    std::vector<double> logPrimes(myMax + 1, 0.0);
    getNPrimes(logPrimes);
    double sumMax = 0.0;
    for (int i = 0; i < n; ++i) {
        IntegerVector v = tempLst[i];
        double mySum = 0.0;
        for (auto j: v)
            mySum += logPrimes[j];
        if (mySum > sumMax)
            sumMax = mySum;
    }
    const uint64_t multiplier = std::numeric_limits<int>::max() / sumMax;
    std::unordered_set<uint64_t> canon;
    canon.reserve(n);
    for (int i = 0; i < n; ++i) {
        IntegerVector v = tempLst[i];
        double mySum = 0.0;
        for (auto j: v)
            mySum += logPrimes[j];
        canon.insert(static_cast<uint64_t>(multiplier * mySum));
    }
    const auto myEnd = canon.end();
    for (auto it = x.begin() + 1; it != x.end(); ++it) {
        List tempLst = *it;
        if (tempLst.length() != n)
            return false;
        for (int j = 0; j < n; ++j) {
            IntegerVector v = tempLst[j];
            double mySum = 0.0;
            for (auto k: v)
                mySum += logPrimes[k];
            const uint64_t key = static_cast<uint64_t>(multiplier * mySum);
            if (canon.find(key) == myEnd)
                return false;
        }
    }
    return true;
}
")})
#       User      System verstrichen 
#      3.507       0.155       3.662

डेटा:

lst1 <- list(list(1,c(2,3,4),c(5,6)) #TRUE
           , list(c(2,3,4),1,c(5,6))
           , list(1,c(2,3,4),c(6,5)))
lst2 <- list(list(c(2,3,4),c(1,5,6)) #FALSE
           , list(c(2,3,6),c(1,5,4))
           , list(c(2,3,4),c(1,5,6)))
lst3 <- list(list(1,c(2,3,4),c(5,6)) #FALSE
           , list(c(2,3,4),1,c(5,6))
           , list(1,c(2,3,5),c(6,4)))
set.seed(7)
N  <- 1e3
lst1 <- lst1[sample(seq(lst1), N, TRUE)]
lst2 <- lst2[sample(seq(lst2), N, TRUE)]
lst3 <- lst3[sample(seq(lst3), N, TRUE)]
N <- 1000
M <- 500
l <- unname(split(1:N,findInterval(1:N,sort(sample(1:N,N/10)),left.open = T)))
lst4 <- lapply(lapply(1:M, 
                     function(k) lapply(l, 
                                        function(v) v[sample(seq_along(v),length(v))])), function(x) x[sample(seq_along(x),length(x))])
— जीकेआई
स्रोत
आपका बहुत बहुत धन्यवाद! मैंने अभी देखा कि मैंने अपने कोड में एक टाइपो बनाया है, जो length(setdiff(Reduce(union,s),Reduce(intersect,s)))==0 मेरी गलती के लिए क्षमा करना चाहिए ....
— थॉमसआईसोड कोडिंग
@ThomasIsCoding उत्तर अपडेट किया गया है। लेकिन मैंने इसे विकी के रूप में बनाया है, इसलिए सभी को अपडेट करने और नए समाधानों को शामिल करने और हर जगह दोहराया नहीं जाने के लिए स्वागत है।
— GKi
आपके प्रयासों के लिए धन्यवाद! मुझे लगता है कि अब मेरा समाधान सुधार के बाद आपके जैसा ही परिणाम देता है, लेकिन आपकी तुलना में धीमा है :)
— थॉमसआईसकोडिंग
बहुत बढ़िया! आप उल्लेखनीय रूप से प्रदर्शन में सुधार करते हैं! मैं आपके समाधान को स्वीकार करता हूँ!
— थॉमसआईकोडिंग
@ chinsoon12 मुझे याद दिलाने के लिए आपका बहुत-बहुत धन्यवाद! अब मैंने इसे अपनी एक और
— धारणा के
3

उम्मीद है कि 2 बार भाग्यशाली

f <- function(lst) {
    s <- lapply(lst, function(x) {
        y <- x[order(lengths(x), sapply(x, min))]
        rep(seq_along(y), lengths(y))[order(unlist(y))]
    })
    length(unique(s))==1L
}

परीक्षण के मामलों:

# should return `TRUE`
lst1 <- list(list(1,c(2,3,4),c(5,6)),
    list(c(2,3,4),1,c(5,6)),
    list(1,c(2,3,4),c(6,5)))

# should return `TRUE`
lst2 <- list(list(1:2, 3:4), list(3:4, 1:2))

# should return `FALSE`
lst3 <- list(list(1,c(2,3,4),c(5,6)), list(c(2,3,4),1,c(5,6)), list(1,c(2,3,5),c(6,4)))

# should return `FALSE`
lst4 <- list(list(c(2,3,4),c(1,5,6)), list(c(2,3,6),c(1,5,4)), list(c(2,3,4),c(1,5,6)))

lst5 <- list(list(1,c(2,3,4),c(5,6)) #TRUE
    , list(c(2,3,4),1,c(5,6))
    , list(1,c(2,3,4),c(6,5)))
lst6 <- list(list(c(2,3,4),c(1,5,6)) #FALSE
    , list(c(2,3,6),c(1,5,4))
    , list(c(2,3,4),c(1,5,6)))
lst7 <- list(list(1,c(2,3,4),c(5,6)) #FALSE
    , list(c(2,3,4),1,c(5,6))
    , list(1,c(2,3,5),c(6,4)))

चेक:

f(lst1)
#[1] TRUE
f(lst2)
#[1] TRUE
f(lst3)
#[1] FALSE
f(lst4)
#[1] FALSE
f(lst5)
#[1] TRUE
f(lst6)
#[1] FALSE
f(lst7)
#[1] FALSE

समय कोड:

library(microbenchmark)
set.seed(0L)
N <- 1000
M <- 100
l <- unname(split(1:N,findInterval(1:N,sort(sample(1:N,N/10)),left.open = T)))
lst <- lapply(lapply(1:M,
    function(k) lapply(l,
        function(v) v[sample(seq_along(v),length(v))])), function(x) x[sample(seq_along(x),length(x))])

f_ThomsIsCoding <- function(lst) {
    s <- Map(function(v) Map(sort,v),lst)
    length(setdiff(Reduce(union,s),Reduce(intersect,s)))==0
}

f_GKi_1 <- function(lst) {
    all(duplicated(lapply(lst, function(x) lapply(x, sort)[order(unlist(lapply(x, min)))]))[-1])
}

f_GKi_2 <- function(lst) {
    s <- lapply(lst, function(x) lapply(x, sort))
    all(duplicated(lapply(s, function(x) x[order(unlist(lapply(x, "[", 1)))]))[-1])
}


f <- function(lst) {
    s <- lapply(lst, function(x) {
        y <- x[order(lengths(x), sapply(x, min))]
        rep(seq_along(y), lengths(y))[order(unlist(y))]
    })
    length(unique(s))==1L
}

microbenchmark(times=3L,
    f_ThomsIsCoding(lst),
    f_GKi_1(lst),
    f_GKi_2(lst),
    f(lst)
)

समय:

Unit: milliseconds
                 expr       min        lq      mean    median        uq      max neval
 f_ThomsIsCoding(lst) 333.77313 334.61662 348.37474 335.46010 355.67555 375.8910     3
         f_GKi_1(lst) 324.12827 324.66580 326.33016 325.20332 327.43111 329.6589     3
         f_GKi_2(lst) 315.73533 316.05770 333.35910 316.38007 342.17099 367.9619     3
               f(lst)  12.42986  14.08256  15.74231  15.73526  17.39853  19.0618     3
— chinsoon12
स्रोत
हां, यह इस बार ठीक काम करता है
— थॉमसआई कोडिंग
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.