Vượt qua trong R hoặc SQL

Question

Tôi hoàn toàn bối rối về một vấn đề và muốn một số hướng dẫn. Tôi chọn các tập hợp ngẫu nhiên gồm 8 số từ tập 1 đến 8 (ví dụ, 5,6,8,1,3,4,2,7) và cố gắng gộp các con số đó dưới dạng tập con của các số thứ tự theo thứ tự họ xuất hiện.

Ví dụ ở trên, nhóm đầu tiên sẽ bắt đầu bằng số 5 thì 6 sẽ được thêm vào. Khi nhấn 8 một thùng mới sẽ được bắt đầu. Bất cứ khi nào chúng tôi nhận được một số thuộc về một nhóm hiện có (ví dụ: khi chúng tôi đạt đến 2, nó có thể được thêm vào nhóm của 1), chúng tôi thêm nó vào đó. Trong ví dụ này, sau tất cả 8 số, chúng tôi sẽ đến:

5,6,7 
8 
1,2 
3,4 

Tổng cộng có 4 nhóm.

Tôi không thực sự quan tâm đến nội dung của các nhóm, tôi chỉ muốn đếm số lượng nhóm có cho một tập hợp ngẫu nhiên 8 chữ số. Tôi dự định lặp qua một bộ 1000 trong số 8 dãy số này.

Answer 1

Tôi không quá quen thuộc với R, nhưng bạn chắc chắn có thể làm điều gì đó như:

setOf8 = your array of 8 numbers 
buckets=0 
for(i = [2,8]) 
{ 
    if((setOf8[i] < setOf8[i-1])) 
    { 
     buckets = buckets + 1 
    } 
} 

EDIT:

Bạn có thể làm một cái gì đó như:

func countBuckets(buckets, set) 
{ 
    set = your array 
    current = 1 
    for(i = [2,size(set)]) 
    { 
     if(set[current] + 1 == set[i]) 
     { 
      set.remove(current) 
      current = set[i-1] 
     } 
    } 
    if(size(set) == 0) 
    { 
     return buckets 
    } 
return countBuckets(buckets + 1, set) 
} 

Answer 2

Nếu bạn là chỉ quan tâm đến số lượng nhóm,

## Your data 
dat <- c(5,6,8,1,3,4,2,7) 

## Get the number of buckets 
count <- 0 
for (i in seq_along(dat)) 
    if (!((dat[i] - 1) %in% dat[1:i])) count <- count+1 
count 
# 4 

và, một cách ngắn gọn hơn trong một chức năng

countBuckets <- function(lst) sum(sapply(1:length(lst), function(i) 
    (!((lst[i]-1) %in% lst[1:i])))) 

Và, đây là một thực hiện đệ quy để có được nội dung của xô.

f <- function(lst, acc=NULL) { 
    if (length(lst) == 0) return(acc) 
    if (missing(acc)) return(Recall(lst[-1], list(lst[1]))) 

    diffs <- sapply(acc, function(x) lst[1] - x[length(x)] == 1) 
    if (any(diffs)) { 
     acc[[which(diffs)]] <- c(acc[[which(diffs)]], lst[1]) 
    } else { acc <- c(acc, lst[1]) } 
    return (Recall(lst[-1], acc)) 
} 

f(dat) 

# [[1]] 
# [1] 5 6 7 
# 
# [[2]] 
# [1] 8 
# 
# [[3]] 
# [1] 1 2 
# 
# [[4]] 
# [1] 3 4 

Answer 3

Tôi không chắc chắn làm thế nào nó sẽ triền Oracle, nhưng kể từ khi bạn đã thêm Server thẻ SQL, đây là một giải pháp T-SQL:

declare @set char(8) = '56813427'; 

with cte as (
    select s.Id, cast(substring(@set, s.Id, 1) as int) as [Item] 
    from dbo.Sequencer s 
    where s.Id between 1 and 8 
    union all 
    select 9 as [Id], 0 as [Item] 
) 
select count(*) as [TotalBuckets] 
from cte s 
    inner join cte n on (s.Item = n.Item - 1) and s.Id > n.Id; 

Ý tưởng đằng sau nó là đếm các trường hợp khi số tiếp theo đi trước số hiện tại, bắt đầu một nhóm mới thay vì tiếp tục một nhóm hiện tại. Vấn đề duy nhất ở đây là với ranh giới, vì vậy tôi đã thêm dấu 0. Nếu không có nó, ít nhất là thiết lập mục (1 trong trường hợp của bạn) không được tính là một xô riêng biệt.

P.S. dbo.Sequencer là một bảng có số nguyên tăng dần. Tôi thường giữ một trong cơ sở dữ liệu để dự án trình tự sắp xếp.

Answer 4

Giải pháp của tôi, không được tách từ nongkrong nhưng khá giống nhau. Bạn lấy số liệu của xô:

x <- as.integer(c(5,6,8,1,3,4,2,7)) 
sum(is.na(sapply(1:length(x), function(i) which((x[i]-1L)==x[1:i])[1L]))) 
# [1] 4 

tôi tin rằng nó có thể vectorize nó, sau đó nó sẽ mở rộng quy mô một cách hoàn hảo.

Answer 5

Lấy cảm hứng từ @jangorecki nhưng nhanh hơn:

x <- sample(8L) 
1 + sum(sapply(2L:8L, function(i) !any(x[i] - x[1:(i - 1L)] == 1))) 

Answer 6

Dưới đây là một câu trả lời vectorized:

ind.mat <- matrix(rep(1:8, each=8), ncol=8) 
ind.mat[upper.tri(ind.mat)] <- NA 
8 - sum(rowSums(matrix(rep(x, 8), ncol=8) - x[ind.mat] == 1, na.rm=TRUE)) 

Lưu ý rằng chúng ta chỉ cần khai báo ind.mat lần, vì vậy quy mô lên tốt để nhân rộng.