Answer 1

怎么样：

library(ggplot2)
ages<- runif(100, 0, 22) #ages 0-22

#parameters for model
a1<-153
b1<-0.51
c1<-0.53

a2<-147
b2<-0.45
c2<-0.43

#generate length with error normally distributed 
length1 <- (a1*exp(-b1*exp(-c1*ages))) +rnorm(100, mean=0, sd=5)
length2 <- (a2*exp(-b2*exp(-c2*ages))) +rnorm(100, mean=0, sd=5)

df<-data.frame(Length=c(length1, length2), age=rep(ages, 2), location=c(rep(1,100), rep(2,100)))


gompertz.locs <- nls(formula = Length ~ 
                       as.numeric(location==1)*a1*exp(-b1*exp(-c1*age)) 
                     + as.numeric(location==2)*a2*exp(-b2*exp(-c2*age)),
                     data = df, 
                     start = list(a1=150,b1=0.5, c1=0.5,
                                  a2=150,b2=0.5, c2=0.5))

a <- coef(gompertz.locs)[c(1,4)]
b <- coef(gompertz.locs)[c(2,5)]
c <- coef(gompertz.locs)[c(3,6)]
df$fit <- a[df$location]*exp(-b[df$location]*exp(-c[df$location]*df$age))

ggplot(df, aes(x=age, y=Length, colour=as.factor(location))) + 
  geom_point() + 
  geom_line(aes(y=fit)) + 
  theme_classic() + 
  labs(colour="Location")

^{在2022-07-06创建的}

Answer 2

我最终自己弄清楚了这个答案。我更改了格式化函数：

formatter: function(value, context) {
   return context.datasetIndex == 1 ? context.chart.data.labels[context.dataIndex] : ' ';
}

Answer 3

Include Will Will检查以查看对象是否通过参考值相同。您可以通过使用一些检查条目的项目是否匹配。

console.log(data1.some(d => d.item === data2.item));

Answer 4

尝试：

WITH StartDates AS (
    SELECT CUSTOMERID, MIN(ASOFDATE) AS StartDate
    FROM #DATA
    WHERE FIRSTORDER = 1
    GROUP BY CUSTOMERID
)
DELETE D
FROM StartDates S
JOIN #DATA D
    ON D.CUSTOMERID = S.CUSTOMERID
    AND D.ASOFDATE < S.StartDate

请参阅

”选择每个客户的第一个订单参考日期，然后使用该信息选择要删除的记录。

Answer 5

您可以执行以下操作：

import os

os.startfile("C:/Users/TestFile.txt", "print")

这将以动词为“打印”的默认开瓶机以其默认开启器启动文件，该文件将打印到您的默认打印机上。仅需要标准库随附的OS模块，

这仅在Windows上使用。因此，如果您希望它可以在其他操作系统上使用，则需要一种检测发送到哪个OS的OS。

Answer 6

因为farm参数是一个休眠实体，所以它可能是hibernateProxy实例。您可能会认为，一个明确的例外表明，当您尝试访问type字段时，但是由于某种原因，在这种情况下，您会获得我上面发布的classcastException。如果您运行调试器并查看代码，您会发现分配的两面确实是完全相同的类，但是farm实例将是类型farm $ hibernateproxy $ ...如果确实是代理对象。

只是解开代理，您将避免此错误:-)

Answer 7

您可以在表单的Mousemove事件中注册。

this.MouseMove += new System.Windows.Forms.MouseEventHandler(this.Form1_MouseMove);


private void Form1_MouseMove(object sender, MouseEventArgs e)
{
    // e.Location.X;
    // e.Location.Y;
}

Answer 8

如果我正确理解，则需要适合“所有大写”等有条件的密码来减去点，同时也没有添加单个大写的积分。像目前一样，在您的示例中，“ ABC”将获得+5，因为一个小写，然后将所有小写的小写损失为5，而晚上为0，而不是-5。

我会在开始时将您的点递减条件放入单个IF语句中，然后将您的所有积分添加条件都放在if语句中，以在其他语句中：

if (userPassword.All(char.IsLower) ||
  userPassword.All(char.IsUpper) ||
  userPassword.All(char.IsDigit) ||
  userPassword.All(c => specialCharacters.Contains(c)) {
    points -= 5;
  } else {
      if (userPassword.Any(char.IsDigit)) {
        points += 5;
      }
      if (userPassword.Any(char.IsLower)) {
        points += 5;
      }
      if (userPassword.Any(char.IsUpper)) {
        points += 5;
      }
      if (userPassword.Any(c => specialCharacters.Contains(c))) {
        points += 5;
      }
    }

另外，如果您需要分开这些点赋予的条件以允许不同条件下的点扣除值的不同值，请使用更多的if if语句对不良情况使用：

if (userPassword.All(char.IsLower) || userPassword.All(char.IsUpper)) {
  points -= 5;
} else if (userPassword.All(char.IsDigit)) {
  points -= 5;
} else if (userPassword.All(c => specialCharacters.Contains(c))) {
  points -= 5;
} else {
  if (userPassword.Any(char.IsDigit)) {
    points += 5;
  }
  if (userPassword.Any(char.IsLower)) {
    points += 5;
  }
  if (userPassword.Any(char.IsUpper)) {
    points += 5;
  }
  if (userPassword.Any(c => specialCharacters.Contains(c))) {
    points += 5;
  }
}

Answer 9

尝试：

s = "there is wall E on the way"
spans = [(0,5), (9,13), (16,18)]


def solution(sentence, location):
    res = list(sentence)
    for start, end in location:
        res[start], res[end] = "<span>" + res[start], "</span>" + res[end]
    return "".join(res)


for s, l in [
    ["there is wall E on the way", [(0,5), (9,13), (16,18)]],
    ["there is wall E on the way", [(0,5), (16,18)]],
    ["there is wall E on the way", [(0,5), (16,22)]],
    ["there is wall E on the way", [(0,11), (16,22)]],
]:
    print(solution(s, l))

输出：

<span>there</span> is <span>wall</span> E <span>on</span> the way
<span>there</span> is wall E <span>on</span> the way
<span>there</span> is wall E <span>on the</span> way
<span>there is wa</span>ll E <span>on the</span> way

Answer 10

您几乎拥有它的

func buildObject<R: MyProtocol>(objectIn: MyProtocol, returnType: R.Type) -> R {
    let returnObject = returnType.init(id: objectIn.id, name: objectIn.name)
    return returnObject
}

关键观察：在任何时候我们都需要objectin的具体类型，因此只需要协议类型即可。

Answer 11

在ExchangeFilterFunction中，您可以访问该请求。您可以使用一些标识符“装饰”您的请求，然后使用它来解决客户端。

1. 您可以添加一些请求标题来识别客户端。
2. 要保持内部，您可以使用WebClient的请求属性，然后从请求对象读取它

webClient.get()
       .uri("...")
       .attributes((attributes) -> attributes.put("internal_client_id", clientId))

Answer 12

DefaultDict是为此设计的。

import collections
mydict = collections.defaultdict(int)

range_val = [str(i).zfill(2) for i in range(100)]

for v in range_val:
   mydict[v] = mydict[v] + 1

Answer 13

可以使用扫描集％1 [+ - /*]将在一组运算符中扫描一个字符。
如果字符不在集合中，scanf将返回0。清洁输入流，然后重试。

#include <stdio.h>
#include <stdlib.h>

int main ( void) {
    char op[2] = "";
    int result = 1;

    printf ("Enter an operator!\n");
    do {
        if ( result != 1) {
            printf ("Enter an operator!\n");
        }
        result = scanf ( "%1[+-/*]", op);
        if ( result == EOF) {
            fprintf ( stderr, "EOF\n");
            return 1;
        }
        int clean = 0;
        while ( ( clean = fgetc ( stdin)) != '\n') { // clean input stream
            if ( clean == EOF) {
                fprintf ( stderr, "EOF\n");
                return 1;
            }
        }
    } while ( result != 1);

    printf ( "operator %s\n", op);

    return 0;
}

Answer 14

正如@galik评论。这是基于意见的。

但是我们可以指出的是：

• 在C ++中，我们不应将原始指针用于拥有的内存
• new和delete应避免使用
• C风格数组，应避免
• 阅读到> data（）将起作用，但不是很好（我的看法）。无论如何，比使用新的并创建内存泄漏更好。

您可以，在简单的中，循环从文件中读取一个字节，然后将每个字节添加到std :: string带有+= 。但这也很笨拙。

最好的是，如果允许您使用C ++语言和库。

顺便提一句。 std :: String也是“变量大小数组”

建议：使用第二个解决方案

Answer 15

只需添加行shift = shift *（len（msg）// len（shift） + 1）在函数开始时，请重复shift，直到比它更长msg（例如，这一行转动数学到MATHMATH）

import string

def vigenere_cipher(msg, shift):
    shift = shift * (len(msg) // len(shift) + 1)
    encrypted = ''
    for i,j in zip(msg,shift):
        new_index = (string.ascii_uppercase.index(i) + string.ascii_uppercase.index(j)) % 26
        encrypted += string.ascii_uppercase[new_index]
    return encrypted

    
print(vigenere_cipher('PYTHON', 'MATH'))

输出：bymoan