“距离”

我们可以考虑一个距离函数，其中“完全正确”的距离为零，其他任何东西都小于100%。在解释这种方法时有很大的回旋余地，但是任何部分的学分而不是“错误！0%”可以被认为是一种更令人安慰的教学方法。

quux <- structure(list(ResponseID = c("p1", "p2", "p3"), Step1 = c(1L, 2L, 2L), Step2 = c(2L, 3L, 23L), Step3 = c(3L, 4L, 7L), Step22 = c(22L, 23L, 12L), Step23 = c(23L, 1L, 17L)), class = "data.frame", row.names = c(NA, -3L))
quux
#   ResponseID Step1 Step2 Step3 Step22 Step23
# 1         p1     1     2     3     22     23
# 2         p2     2     3     4     23      1
# 3         p3     2    23     7     12     17

# you should probably use 1:23, but I only have a subset of data
correct <- c(1, 2, 3, 22, 23)

字符串
第一个距离函数严重地惩罚了（例如）Step23对于回答者2，因为绝对差是23 - 1 = 22。数学上简单地是n-dim数据的毕达哥拉斯。我将使用quux[,-1]排除ResponseID列。

do.call(mapply, c(list(FUN = function(...) sqrt(sum((unlist(list(...)) - correct)^2))), quux[,-1]))
# [1]  0.00000 22.09072 24.37212

型
这里，0.000显然是100%，其他都是各种程度的“不对”，在这个5题的情况下，最差的是刚刚超过45.7，其中Step1=23，Step2=22，...，Step23=1;如果23都是完全反向的，那么这里的罚分是

sqrt(sum((1:23 - 23:1)^2))
# [1] 63.62389

型
如果你认为22.09072值得一个线性偏导数，那么就交给你了，

100 * (63.62389 - do.call(mapply, c(list(FUN = function(...) sqrt(sum((unlist(list(...)) - correct)^2))), quux[,-1]))) / 63.62389
# [1] 100.00000  65.27920  61.69345
### percent

型
这是草率的，在接受全权委托之前真的应该考虑清楚。
另一个想法是，你采取的是正确/错误的存在，而不是距离。也就是说，Step23=1的值为1，Step23=22的值为1，但正确的值为0。

do.call(mapply, c(list(FUN = function(...) sqrt(sum(unlist(list(...)) != correct))), quux[,-1]))
# [1] 0.000000 2.236068 2.236068

型
注意，我们这里不需要^2，因为它总是0或1，所以平方什么也不做。（如果它让你对这个方法的毕达哥拉斯性质感觉更好，你可以随意保留它。）
我们可以很容易地用==代替!=，100%的值是2.236，但我想我会和第一部分开始的反演一致。
完全错误的（所有23个都是1个或更多）仅仅是

sqrt(sum(2:24 != 1:23))
# [1] 4.795832

“最长序列”

你链接的文章倾向于从数字中找到“最长的正确排序的链”。如果你看https://www.r-bloggers.com/2014/09/compute-longest-increasingdecreasing-subsequence-using-rcpp/，这是一个在数字序列中找到最长链的方法。
使用其功能：

longest_subseq <- function(x) {
    P = integer(length(x))
    M = integer(length(x) + 1)
    L = newL = 0
    for (i in seq_along(x) - 1) {
        lo = 1
        hi = L
        while (lo <= hi) {
            mid = (lo + hi)%/%2
            if (x[M[mid + 1] + 1] < x[i + 1]) {
                lo = mid + 1
            } else {
                hi = mid - 1
            }
        }
        newL = lo
        P[i + 1] = M[newL]
        if (newL > L) {
            M[newL + 1] = i
            L = newL
        } else if (x[i + 1] < x[M[newL + 1] + 1]) {
            M[newL + 1] = i
        }
    }
    k = M[L + 1]
    re = integer(L)
    for (i in L:1) {
        re[i] = k + 1
        k = P[k + 1]
    }
    re
}

然后，我们可以找到（每行中）有多少个数字是正确的顺序：

longest_subseq(c(1, 2, 3, 22, 23))
# [1] 1 2 3 4 5  ## length 5, perfect score!
longest_subseq(c(2, 3, 4, 23, 1))
# [1] 1 2 3 4    ## length 4
longest_subseq(c(2, 23, 7, 12, 17))
# [1] 1 3 4 5    ## length 4

并将其自动化，

do.call(mapply, c(list(FUN = function(...) length(longest_subseq(unlist(list(...))))), quux[,-1]))
# [1] 5 4 4

在这种情况下，回答者1以正确的顺序拥有所有五个（这些）;回答者2和3只有一个不符合首选的相对顺序。
这种方法提供了一个更清晰的评分：所有23个顺序是100%