प्रोग्रामिंग, पंक्ति-वार डेटा फ्रेम गणना कस्टम स्क्रिप्ट के साथ (हर i के लिए) "ब्रिज गेम" को हल करने के लिए

Nov 25 2020

मेरे पास एक डेटा फ़्रेम है जो "ब्रिज गेम्स" को निर्दिष्ट करता है (प्रत्येक पंक्ति एक स्वतंत्र गेम है), नीचे दिए गए 4 गेम के साथ एक न्यूनतम उदाहरण देखें:

start <- list(c("10","15","5"), c("5") ,c("11","6"),c("6","11"))
end <- list(c("7","17","11"), c("10"), c("8","12"),c("8","12"))
ascending <- c("+","-","+","-")
position <- c(11,6,9,8)
desired_output <- c(5,5,"disqualified",3)

bridge_game <- data.frame(start = I(start), end = I(end), ascending = ascending, position = position, desired_output = desired_output)

bridge_game

ब्रिज गेम कैसे काम करता है? दुनिया भर के उम्मीदवार एक पुल गेम चुनौती में भाग लेते हैं और हमने हर ब्रिज गेम के डेटा को डेटा फ्रेम में एकत्र किया है। हर पुल में गिने हुए लकड़ी के पैनल (सकारात्मक पूर्णांक होते हैं जो जरूरी नहीं कि 1 पर शुरू होते हैं) और टूटे पैनल के "अंतराल" होते हैं। उम्मीदवार चुन सकता है कि पुल के किस तरफ से वह अपना चलना शुरू कर रहा है (आरोही = पैनल की संख्या बढ़ने के साथ-साथ वॉक बढ़ती है, या उतरते हुए = वॉक की प्रगति के रूप में पैनल की संख्या कम हो जाती है)।

ब्रिज गेम की बेहतर समझ के लिए एक ग्राफिक यहाँ पाया जा सकता है (डेटा फ्रेम में पहली पंक्ति के लिए अनुकरणीय): यहाँ क्लिक करें

हर ब्रिज गेम (डेटा फ़्रेम में पंक्ति) के लिए हमारे पास निम्न जानकारी (= कॉलम) है:

  • Bridge_game $ start : सभी पूरे लकड़ी के पैनलों के ट्रैक्स की स्थिति शुरू करें (यादृच्छिक क्रम)
  • Bridge_game $ अंत : पूरे लकड़ी के पैनलों के ट्रैक्ट के सभी अंतिम स्थान (यादृच्छिक क्रम)
  • पुल_ गेम $ आरोही : आरोही (+) या अवरोही (-) क्रम में पुल के पार चलें
  • Bridge_game $ स्थिति : उम्मीदवार संकेतित पैनल पर समाप्त हुआ

चुनौती क्या है? मुझे एक स्क्रिप्ट लिखने की आवश्यकता है जिसे मैं निम्नलिखित आउटपुट प्राप्त करने के लिए पूरे डेटा फ्रेम पर पंक्ति-वार चला सकता हूं:

  • ब्रिज_ गेम $ वांछित_आउटपुट : परीक्षण करें कि क्या उम्मीदवार नदी में गिर गया (टूटे हुए पैनल पर समाप्त हो गया और "अयोग्य घोषित कर दिया गया")। और अगर वह अयोग्य नहीं है, तो मुझे उम्मीदवार के चलने से कवर किए गए पूरे लकड़ी के पैनलों की संख्या की गणना करने की आवश्यकता है (टूटे हुए पैनल गिनती नहीं करते हैं)।

महत्वपूर्ण रूप से, यह लकड़ी के पैनलों के पूरे पथ के किसी भी संख्या i के लिए काम करना चाहिए ।

अधिक सटीक होने के लिए मैं एक कदम-दर-चरण निर्देश देता हूं कि अनुरोधित आर स्क्रिप्ट को नीचे कैसे संचालित किया जाना चाहिए:

0) हल किया

क) कॉलम ब्रिज_ गेम $ प्रारंभ और ब्रिज_ गेम $ एंड के लिए संख्यात्मक सूची में पात्रों की सूची बदलें।

बी) मैं गणना करता हूं (पूरे लकड़ी के पैनलों की संख्या; मैं हर पंक्ति के लिए 1 से i = अधिकतम तक जाता हूं ) और हर I के लिए सही शुरुआत और अंत मान प्राप्त करने के लिए शुरुआत और अंत की स्थिति को सॉर्ट करता हूं

1) परीक्षण करें कि स्थिति टूटे हुए पैनल में है या नहीं: अंत (i = 1 से अधिकतम -1)> स्थिति> प्रारंभ (i = 2 से अधिकतम) -> यदि परीक्षण किए गए किसी भी जोड़े के लिए सही है -> "अयोग्य"

2) यदि नहीं, तो परीक्षण करें कि पूरे पैनल की किस स्थिति में दी गई स्थिति निहित है ( i = n ): प्रारंभ (i = 1 से अधिकतम) <= स्थिति <= अंत (i = 1 से अधिकतम) -> यदि TRUE वापस दे मैं (= n)

3)

a) इस सूत्र को लागू करें (यदि दिशा आरोही "+" और n = 1 है): आउटपुट = स्थिति - प्रारंभ (i = 1) 1

बी) इस सूत्र को लागू करें (यदि दिशा अवरोही है "-" और n = i अधिकतम): आउटपुट = अंत (i = अधिकतम) - स्थिति + १

ग) इस सूत्र को लागू करें (यदि दिशा "+" और n> 1 है): आउटपुट = स्थिति - प्रारंभ (i = 1) + 1 - (प्रारंभ (i = 2 से n) - अंत (i = 1 से n-) 1) - 1x [एन -1])

d) इस सूत्र को लागू करें (यदि दिशा अवरोही है "-" और n <i अधिकतम): आउटपुट = अंत (i = अधिकतम) - स्थिति + 1 - (प्रारंभ (i = n + 1 से अधिकतम) - अंत (i = n) से अधिकतम -1) - 1x [i = max - n])

मुझे उम्मीद है कि मुझे वहीं गणित मिल गया होगा। सही आउटपुट की जाँच करने के लिए मैंने "Bridge_game" डेटा फ़्रेम में "वांछित_आउटपुट" कॉलम बनाया है।

आपकी सहायताके लिए धन्यवाद!

जवाब

3 YaroslavDanko Nov 29 2020 at 03:01

ऐसा लगता है कि मेरे पास चरण 3 के लिए अधिक सरल समाधान है। फ़ंक्शन npanelsपैनल संख्याओं से एक वेक्टर बनाता है, इसमें खिलाड़ी के रुकने की स्थिति निर्धारित करता है। यदि आंदोलन की दिशा सकारात्मक है ( ascendingचर है "+"), तो यह वांछित समाधान है, यदि नकारात्मक है, तो इस वेक्टर की लंबाई के आधार पर वांछित मूल्य की गणना की जाती है।

start <- list(c(5,10,15), c(5) ,c(6,11),c(6,11))
end <- list(c(7,11,17), c(10), c(8,12),c(8,12))
position <- c(11,6,9,8)
ascending <- c("+","-","+","-")
game <- data.frame(start = I(start), end = I(end), position = position, ascending = ascending)

npanels <- function (data) {
  v <- unlist(Map(":",
                  unlist(data[["start"]]),
                  unlist(data[["end"]])))
  p <- which(v == data[["position"]])
  l <- length(v)
  b <- 1+l-p
  d <- data[["ascending"]]
  n <- ifelse(d == "+", p, b)
  n <- if(is.na(n)) "disqualified" else n
  return(n)
}

game$solution <- apply(game, 1, npanels)

game
4 ekoam Nov 29 2020 at 02:52

आपने इस समस्या को समाप्त कर दिया है। निम्नलिखित कार्यान्वयन पर विचार करें

parse_pos <- function(x) sort(as.integer(x))

construct_bridge <- function(starts, ends) {
  starts <- parse_pos(starts); ends <- parse_pos(ends)
  bridge <- logical(tail(ends, 1L))
  whole_panels <- sequence(ends - starts + 1L, starts)
  bridge[whole_panels] <- TRUE
  bridge
}

count_steps <- function(bridge, direction, stop_pos) {
  if (isFALSE(bridge[[stop_pos]]))
    return("disqualified")
  start_pos = c("+" = 1L, "-" = length(bridge))[[direction]]
  sum(bridge[start_pos:stop_pos])
}

play_games <- function(starts, ends, direction, stop_pos) {
  mapply(function(s, e, d, sp) {
    bridge <- construct_bridge(s, e)
    count_steps(bridge, d, sp)
  }, starts, ends, direction, stop_pos)
}

उत्पादन

> with(bridge_game, play_games(start, end, ascending, position))
[1] "5"            "5"            "disqualified" "3" 

यहां कुंजी यह है कि हम एक पुल का प्रतिनिधित्व करने के लिए एक तार्किक वेक्टर का उपयोग कर सकते हैं, जहां एक टूटे हुए / पूरे पैनल को अनुक्रमित किया जाता है F/ T। फिर हम सिर्फ यह परीक्षण करते हैं कि स्टॉप की स्थिति पूरे पैनल पर है या नहीं। प्रारंभ से अंत स्थिति तक पैनलों का योग लौटाएं यदि ऐसा है (तो टूटे हुए पैनल योग को प्रभावित नहीं करेंगे क्योंकि वे अभी शून्य हैं) या "अयोग्य" अन्यथा।

2 Ben Nov 29 2020 at 02:09

यह आपको आपके तीसरे चरण के लिए जो आवश्यक है, प्रदान कर सकता है। मैंने आपके अन्य पोस्ट से फ़ंक्शन को संशोधित किया है ।

सबसे पहले, जाँच करेगा कि क्या n(या region) है NA। अगर ऐसा है, तो positionबीच startऔर मैच का कोई मेल नहीं था end

अन्यथा, आप के 2x2 संयोजन शामिल कर सकते हैं if elseपर देख रहे हैं ascendingऔर n। समीकरण मानों के समान निष्कर्षण का उपयोग करते हैं x। ध्यान दें, ऐसा लगता है कि आप sumउन मानों को चाहते हैं जहाँ सूचकांकों की एक श्रेणी है (उदाहरण के लिए, जब आप कहते हैं "प्रारंभ (i = 2 से n)" आप sumमानों को चाहते हैं, जैसे कि sum(start[2:n]))।

ध्यान दें कि यह आपके समीकरण को कोड में सीधे अनुवाद करता है जैसा कि वांछित था। हालांकि, अन्य उत्तरों में वर्णित तर्क के आधार पर सरल विकल्प हैं।

start <- list(c(5,10,15), c(5) ,c(6,11),c(6,11))
end <- list(c(7,11,17), c(10), c(8,12),c(8,12))
ascending <- c("+","-","+","-")
imax <- c(3,1,2,2)
position <- c(11,6,9,8)

example <- data.frame(start = I(start), end = I(end), ascending = ascending, imax = imax, position = position)

my_fun <- function(x) {
  n <- NA
  out <- NA
  start <- as.numeric(unlist(x[["start"]]))
  end <- as.numeric(unlist(x[["end"]]))
  for (i in 1:x[["imax"]]) {
    if (between(x[["position"]], start[i], end[i])) n <- i
  }
  if (!is.na(n)) {
    if (x[["ascending"]] == "+") {
      if (n == 1) {
        out <- x[["position"]] - start[1] + 1
      } else if (n > 1) {
        out <- x[["position"]] - start[1] + 1 - (sum(start[2:n]) - sum(end[1:(n-1)]) - (n - 1))
      }
    } else if (x[["ascending"]] == "-") {
      if (n == x[["imax"]]) {
        out <- end[x[["imax"]]] - x[["position"]] + 1  
      } else if (n < x[["imax"]]) {
        out <- end[x[["imax"]]] - x[["position"]] + 1 - (sum(start[(n+1):x[["imax"]]]) - sum(end[n:(x[["imax"]] - 1)]) - (x[["imax"]] - n))
      }
    }
  }
  out
}

example$desired_output <- apply(example, 1, my_fun) 

उत्पादन

      start       end ascending imax position desired_output
1 5, 10, 15 7, 11, 17         +    3       11              5
2         5        10         -    1        6              5
3     6, 11     8, 12         +    2        9             NA
4     6, 11     8, 12         -    2        8              3
Quad89 Nov 27 2020 at 01:05

अपडेट करें:

चरण ०) किया जाता है:

#Change to numeric
bridge_game$start <- lapply(bridge_game$start, as.numeric)
bridge_game$end <- lapply(bridge_game$end, as.numeric)

#Calculate number of tracts of whole wooden panels
bridge_game$tracts <- lapply(bridge_game$start, length)

#Sort start and end positions
bridge_game$start <- lapply(bridge_game$start, sort)
bridge_game$end <- lapply(bridge_game$end, sort)

#Calculate number of tracts of whole wooden panels
bridge_game$tracts <- lapply(bridge_game$start, length)

चरण 1 से संघर्ष) पर ...