All perguntas(coding)

esta é a aparência da parte relevante de um documento:

{
  "map": {
    "cities": [
      {
        "name": "City1",
        "x": 15,
        "y": 5,
        "owner": 1,
        "defense": 6,
        "income": 35
      },
      {
        "name": "City2",
        "x": 12,
        "y": 14,
        "owner": 0,
        "defense": 4,
        "income": 16
      },
      {
        "name": "City3",
        "x": 6,
        "y": 19,
        "owner": 2,
        "defense": 3,
        "income": 12
      }
    ]
  },
  "players": [
    {
      "userid": "64d3ebfb42fb5b118b928f5c",
      "faction": 1
    },
    {
      "userid": "636f89f0d4666b666237cec8",
      "faction": 2
    }
  ]
}

Agora, como escrever uma consulta que produza isso, se eu for o jogador 1 (userid: "64d3ebfb42fb5b118b928f5c"):

{
  "map": {
    "cities": [
      {
        "name": "City1",
        "x": 15,
        "y": 5,
        "owner": 1,
        "defense": 6,
        "income": 35
      },
      {
        "name": "City2",
        "x": 12,
        "y": 14,
        "owner": 0
      },
      {
        "name": "City3",
        "x": 6,
        "y": 19,
        "owner": 2
      }
    ]
  }
}

No caso do jogador 2 ele retornará (userid: "636f89f0d4666b666237cec8"):

{
  "map": {
    "cities": [
      {
        "name": "City1",
        "x": 15,
        "y": 5,
        "owner": 1
      },
      {
        "name": "City2",
        "x": 12,
        "y": 14,
        "owner": 0
      },
      {
        "name": "City3",
        "x": 6,
        "y": 19,
        "owner": 2,
        "defense": 3,
        "income": 12
      }
    ]
  }
}

• a consulta deve levar apenas o ID do usuário como entrada
• somente onde "players.faction" corresponde a "map.cities.owner", os valores reais de "defesa" e "renda" são mostrados
• um jogador não verá os valores das cidades que não possui
• uma alternativa poderia ser que os valores padrão sejam, por exemplo, 0 se o jogador não for o dono da cidade

Eu sei que posso apenas consultá-lo e removê-lo programaticamente, mas me pergunto se isso pode ser feito de alguma forma melhor.

Eu tentei assim, mas obviamente não funciona porque "$map.cities.owner"/"$map.cities.defense" na verdade é/retorna um array.

{
  _id: 0,
  "map.cities.name": 1,
  "map.cities.x": 1,
  "map.cities.y": 1,
  "map.cities.owner": 1,
  "map.cities.defense": {
    $cond: {
      if: {
        $eq: ["$map.cities.owner", 1],
      },
      then: "$map.cities.defense",
      else: "$$REMOVE",
    },
  },
}

Tentei usar $filter, mas rapidamente ficou muito complicado e nunca obtive o resultado que procurava.

Tentei usar $unwind, map.citiesmas tive dificuldade para colocá-lo em um único documento novamente.

Meu objetivo é criar linhas curvas em um mapa (conectando pontos), com uma seta de um lado. Essas linhas serão semitransparentes. Parece que a melhor maneira de atingir meu objetivo é usar geom_curve(embora outras ggplot2soluções também sejam ótimas).

Como tal, digamos que tenho este enredo de brinquedo:

library(tidyverse)
library(ggplot2)
data <- data.frame(x = 4, y = 20, xend = 7, yend = 15)

ggplot(data) + geom_curve(aes(x = x, y = y, xend = xend, yend = yend),
    arrow = arrow(length = unit(0.17, "npc"), type="closed", angle=20),
    colour = "red",
    linewidth = 5,
    angle = 90, 
    alpha=.2,
    lineend = "butt",
    curvature = -0.4,
) 

Isso cria:

O problema que estou enfrentando é que, ao usar geom_curveuma linha semitransparente, a seta aparece com diferentes níveis de transparência quando quero que fique uniforme. Como posso evitar isso?

Esta questão está intimamente relacionada com: A estética alfa mostra o esqueleto da flecha em vez de uma forma simples - como evitá-lo? , exceto que ele usa geom_curveem vez de geom_segment. A resposta brilhante ( https://stackoverflow.com/a/60587296/2049545 ) define uma nova geometria ( geom_arrowbar). Seria possível modificar isso para ser usado geom_curve? Também sinalizarei outra resposta que aponta para geom_gene_arrow( https://stackoverflow.com/a/60655018/2049545 ) - isso pode ser usado com linhas curvas? Ou existe alguma outra solução que funcionaria?

Não entendo por que restringir um genérico não utilizado causa um erro de compilação. Por que isso compila:

#[derive(PartialEq)]
struct B;

fn is_eq<T>(b: B, c: B) -> bool 
// where
//     B: PartialEq<T>,
{
    b == c
}

mas remover o comentário da cláusula where causa este erro de compilação:

error[E0308]: mismatched types
 --> src/lib.rs:9:10
  |
4 | fn is_eq<T>(b: B, c: B) -> bool
  |          - this type parameter
...
8 |     b == c
  |          ^ expected type parameter `T`, found `B`
  |
  = note: expected type parameter `T`
                     found struct `B`

Fazendo as ==compilações explícitas, ou seja PartialEq::<B>::eq(&b, &c)- embora não deveria estar claro para o compilador usar esta implementação? Estranhamente, alterando os parâmetros de entrada para &B e usando ==compilações. Seria ótimo saber por que há um erro e o que está acontecendo aqui.

Encontrei o seguinte código:

try (Stream<String> lines = Files.lines(path, charset)) {
    for (String line : (Iterable<String>) lines::iterator) {
        //logic
    }
}

Este código é compilado e funciona conforme o esperado. Porém, não consigo entender esta peça: (Iterable<String>) lines::iterator. Pelo que entendi, um loop for-each é for (Foo foo: Iterable<Foo> iterable) {}. Mas como a referência do método pode ser convertida Iterable? Alguém poderia explicar?

Então aqui está um exemplo.

#include <stdio.h>

int main(void){
    int score1 = 70, score2 = 58, score3 = 99;

    float total = 3;
    printf("Average: %f\n", (score1 + score2 + score3)/total);
}

e isso me dá 75.666664. enquanto se eu substituir total por apenas 3.0 como este código

#include <stdio.h>

int main(void){
    int score1 = 70, score2 = 58, score3 = 99;
    printf("Average: %f\n", (score1 + score2 + score3)/3.0);
}

isso me dá75.666667.

Atualização: como parece ser um bug do compilador, enviei um relatório à Microsoft .

A saída do código a seguir me surpreende. Minha expectativa é que ele Innerteria num1inicializado em 10 (como está) e depois num2seria inicializado, copiando num1o valor de 10. Portanto, a saída seria 10 10. Em vez disso, eu entendo 10 4.

#include <iostream>

struct Inner {
    uint64_t num1{10};
    uint64_t num2{num1};
};

struct Outer {
    uint64_t a{};
    Inner inner{};
};

Outer makeOuter() {
    return {.a = 4};
}

int main(int argc, char* argv[]) {
    auto outer = makeOuter();
    std::cout << outer.inner.num1 << " " << outer.inner.num2 << std::endl;
    return 0;
}

num2parece copiar memória não inicializada (ou do endereço errado?). Ele recebe o valor do Outermembro de a, seja ele 4 ou 0xFFFFFFFFFFFFFFFF.

O compilador é MSVC 19.37.32825.0. Compile, por exemplo, executando cl main.cpp /std:c++latest /EHsc /O2 /link /out:program.exe.

Com clang++ ou g++, obtenho o resultado esperado, 10 10. Bug do compilador ou meu mal-entendido?

Os efeitos de algumas outras mudanças:

• Adicionar um construtor Inner() {}à Inner-> saída torna-se10 10
• Mudar Inner inner{}para Inner inner{11, 12}-> a saída torna-se 11 12(esperada)
• Mudar Inner inner{}para Inner inner{11}-> saída torna-se11 4
• Retornar {}em vez de {.a = 4}-> a saída torna-se10 10
• Criando Inner inner{}diretamente maine imprimindo seus membros -> a saída torna-se10 10

Estou experimentando o chromotepacote como substituto do RSelenium. Vejo como navegar para um URL específico, mas não consigo identificar o comando a ser usado para obter o URL atual. Nele RSeleniumestava getCurrentUrl(); nele webdriverestava getUrl().

Existe um equivalente em chromote?

Aqui está o que eu tenho:

library(chromote)
session <- ChromoteSession$new()
session$Page$navigate("https://stackoverflow.com")

# some clicks etc on the page

# Now where did I end up?

Este é o meu código de exemplo:

#include <type_traits>

template <bool B>
struct S {
    // #1
    // template <bool C = B, class = std::enable_if_t<!C>>
    // operator S<true>() const { return {}; }

    // #2
    // operator S<true>() const { return {}; }
};

int main() {
    S<true> b1;
    S<false> b2;
}

Ao compilar com g++ ( https://godbolt.org/z/P46qE8EGG ), não recebo nenhum aviso se habilito a opção 1, a opção 2 ou ambas. Eu esperaria um aviso de que é uma função de autoconversão quando eu habilitar o número 2, mas talvez o g++ não tenha esse aviso.

O verdadeiro problema é ao compilar com o clang. Recebo os seguintes avisos apenas se ativar o número 1:

erro: a função de conversão que converte 'S' para si mesmo nunca será usada [-Werror,-Wclass-conversion]

A ativação do nº 2 não aciona esse aviso e a desativação da instanciação de um deles b1ou b2não o impede. O que está acontecendo? Isso é um erro no clang?

EDIT: estou me referindo especificamente ao motivo pelo qual o número 1 produz o aviso. A outra informação pretendia mostrar minhas tentativas de tentar restringir o problema a um exemplo funcional menor

De acordo com CPPReference , #ifé seguido por uma expressão constante. sizeofé um operador válido em expressões constantes. Mas quando escrevo isso e compilo com clang ou gcc, ele falha:

#if sizeof(char) == 1
#endif

saída do clang:

sizeof in preprocessor directive.c:1:5: error: function-like macro 'sizeof' is not defined
#if sizeof(char) == 1
    ^
1 error generated.

Saída do gcc:

sizeof in preprocessor directive.c:1:11: error: missing binary operator before token "("
    1 | #if sizeof(char) == 1
      |           ^

O CPPReference está errado ou os compiladores estão errados?

Eu tenho uma lista (com número ímpar de elementos):

my.list = list(col1 = c("CC", "CT", "TT"), 
     col2 = c("GG", "GT"), 
     col3 = c("CC", "CT"),
     col4 = c("CC", "CG", "GG"), 
     col5 = c("AC", "CC"),
     col6 = "GG")

$col1
[1] "CC" "CT" "TT"

$col2
[1] "GG" "GT"

$col3
[1] "CC" "CT"

$col4
[1] "CC" "CG" "GG"

$col5
[1] "AC" "CC"

$col6
[1] "GG"

Que pode ser transformado em um quadro de dados:

mylist.df = plyr::ldply(my.list, rbind)
names(mylist.df) <- c("cols","g1", "g2", "g3")

E quero criar um subconjunto do quadro de dados abaixo usando mylistou mylist.df. Basicamente, quero manter todas as linhas que tenham pelo menos um elemento de cada valor em mylist:

df.to.subset = structure(list(IDs = c("ID1", "ID2", "ID3", "ID4", "ID5", "ID6"), 
               gr = c("gr1", "gr1", "gr1", "gr1", "gr1", "gr1"), 
               var = c(-3.451, -3.469, -3.837, -3.344, -3.904, -3.943), 
               col1 = structure(c(1L, 2L, 3L, 1L, 2L, 2L), levels = c("CC", "CT", "TT"), class = "factor"), 
               col2 = structure(c(1L, 1L, 2L, 3L, 3L, 3L), levels = c("GG", "GT", "TT"), class = "factor"), 
               col3 = structure(c(1L, 2L, 1L, 1L, 1L, 1L), levels = c("CC", "CT"), class = "factor"), 
               col4 = structure(c(2L, 2L, 2L, 2L, 2L, 2L), levels = c("CC", "CG", "GG"), class = "factor"), 
               col5 = structure(c(1L, 2L, 2L, 2L, 2L, 2L), levels = c("AC", "CC"), class = "factor"), 
               col6 = structure(c(1L, 1L, 2L, 1L, 1L, 1L), levels = c("GG","AA"), class = "factor")), 
          row.names = c(NA, 
                        -6L), class = c("tbl_df", "tbl", "data.frame"))

  IDs   gr      var col1  col2  col3  col4  col5  col6 
  <chr> <chr> <dbl> <fct> <fct> <fct> <fct> <fct> <fct>
1 ID1   gr1   -3.45 CC    GG    CC    CG    AC    GG   
2 ID2   gr1   -3.47 CT    GG    CT    CG    CC    GG   
3 ID3   gr1   -3.84 TT    GT    CC    CG    CC    AA   
4 ID4   gr1   -3.34 CC    TT    CC    CG    CC    GG   
5 ID5   gr1   -3.90 CT    TT    CC    CG    CC    GG   
6 ID6   gr1   -3.94 CT    TT    CC    CG    CC    GG   

(O resultado final seria)

  IDs   gr      var col1  col2  col3  col4  col5  col6 
  ID1   gr1   -3.45 CC    GG    CC    CG    AC    GG   
  ID2   gr1   -3.47 CT    GG    CT    CG    CC    GG   

Além disso, gostaria de nivelar novamente cada coluna para df.to.subsetcorresponder aos níveis deste quadro de dados:

factor.levels.cols = structure(list(cols = c("col1", "col2", "col3", "col4", "col5", "col6"), 
               g1 = c("CC", "GG", "CC", "CC", "AA", "AA"), 
               g2 = c("CT", "GT", "CT", "CG", "AC", "AG"), 
               g3 = c("TT", "TT", "TT", "GG", "CC", "GG")), 
          row.names = c(NA, 6L), class = "data.frame")

  cols g1 g2 g3
1 col1 CC CT TT
2 col2 GG GT TT
3 col3 CC CT TT
4 col4 CC CG GG
5 col5 AA AC CC
6 col6 AA AG GG

Um loop for é obrigatório aqui ou existe uma maneira de torná-lo mais rápido? Tenho mais de 1.000.000 de entradas para modificar.