All perguntas(coding)

Atualmente estou aprendendo sobre ferrugem e gostaria de coletar uma referência de strings (&strs) de um vetor de itens que possuem uma String.

struct Channel {
    cid: usize,
    name: String,
}

fn main() {
    let channels: Vec<Channel> = vec![Channel {
        cid: 1,
        name: "Hello".to_string(),
    }];
    let names: Vec<&str> = channels.iter().map(|x| &x.name).collect();
}

Este código não compila, dando este erro:

[E0277]: a value of type `Vec<&str>` cannot be built from an iterator over elements of type `&String`
    --> src/main.rs:11:61
     |
11   |     let names: Vec<&str> = channels.iter().map(|x| &x.name).collect();
     |                                                             ^^^^^^^ value of type `Vec<&str>` cannot be built from `std::iter::Iterator<Item=&String>`
     |
     = help: the trait `FromIterator<&String>` is not implemented for `Vec<&str>`
     = help: the trait `FromIterator<&str>` is implemented for `Vec<&str>`
     = help: for that trait implementation, expected `str`, found `String`
note: the method call chain might not have had the expected associated types
    --> src/main.rs:11:44
     |
7    |       let channels: Vec<Channel> = vec![Channel {
     |  __________________________________-
8    | |         cid: 1,
9    | |         name: "Hello".to_string(),
10   | |     }];
     | |______- this expression has type `Vec<Channel>`
11   |       let names: Vec<&str> = channels.iter().map(|x| &x.name).collect();
     |                                       ------ ^^^^^^^^^^^^^^^^ `Iterator::Item` changed to `&String` here
     |                                       |
     |                                       `Iterator::Item` is `&Channel` here
note: required by a bound in `collect`
    --> /playground/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2050:19
     |
2050 |     fn collect<B: FromIterator<Self::Item>>(self) -> B
     |                   ^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Iterator::collect`

Posso fazê -lo funcionar chamando as_str() para extrair a fatia da string:

let names: Vec<&str> = channels.iter().map(|x| x.name.as_str()).collect();

No entanto, gostaria de entender por que isso é necessário. Pelo que entendi, devido à coerção deref, a &Stringpode ser convertido em a &str. Por que preciso usar explicitamente as_str()? Além disso, em termos de desempenho, tomar é as_str()o mesmo que fazer referência a um item?

Obtenho sizeof()resultados estranhos [[no_unique_address]]no g++ 13.2.

#include <iostream>

using namespace std;

template<bool T>
struct B
{
    struct Dummy {};

    int *a; // swap position with <below placemark>
    // In this position, results are "16" and "40".
    
    [[no_unique_address]] std::conditional_t<T, Dummy, size_t> y;
    [[no_unique_address]] std::conditional_t<T, Dummy, size_t> x;
    [[no_unique_address]] std::conditional_t<T, Dummy, size_t> h;
    [[no_unique_address]] std::conditional_t<T, Dummy, size_t> w;
    
    // <below placemark>
    // In this position, results are "8" and "40".
    
};

int main()
{
    cout << sizeof(B<true>) << "\n";
    cout << sizeof(B<false>) << "\n";
}

O resultado é

16
40

mas se você mudar int *a;para a posição após as [[no_unique_address]]linhas, você obterá

8
40

Além disso, com apenas uma [[no_unique_address]]linha e com a variável de ponteiro de membro antes, os resultados estão corretos:

8
16

Eu li a documentação, [[no_unique_address]]mas não faço nada específico.

Por que isso acontece?

• atomic_flag_test_and_set Sim!
• atomic_flag_clear Sim!
• atomic_flag_test_and_clear não
• atomic_flag_set não

Se você quiser fazer algo como definir um sinalizador em um evento em algum contexto e, em algum outro contexto, verificar e limpar o evento, o C/C++ não permite que você faça uma única chamada atômica por contexto.

Você teria que inverter o sinalizador, então limpe o sinalizador do evento, verifique e defina o sinalizador ao verificar o evento.

Não é grande coisa, mas parece um retrocesso neste cenário, especialmente considerando que o estado padrão da bandeira é falso, o que no sentido invertido significa que o evento é declarado por padrão.

Suponho que, alternativamente, um atômico boolwith atomic_exchangepoderia ser usado.

O trecho de código a seguir é executado sem erros no Java 8. No entanto, quando executo o mesmo código no Java 17, ele falha.

import java.time.OffsetDateTime;
import java.time.format.DateTimeFormatter;

public class Main2 {
    public static void main(String[] args) {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH[:mm[:ss[.SSS]]]X");
        OffsetDateTime offSetDateTime = OffsetDateTime.parse("2021-10-09T08:59:00.00Z", formatter);
        System.out.println(offSetDateTime);
    }
}

Saída quando executado em Java 17:

Exception in thread "main" java.time.format.DateTimeParseException: Text '2021-10-09T08:59:00.00Z' could not be parsed at index 19
    at java.base/java.time.format.DateTimeFormatter.parseResolved0(DateTimeFormatter.java:2052)
    at java.base/java.time.format.DateTimeFormatter.parse(DateTimeFormatter.java:1954)
    at java.base/java.time.OffsetDateTime.parse(OffsetDateTime.java:404)
    at Main2.main(Main2.java:9)

No entanto, se eu executar o mesmo código no Java 8, o seguinte resultado será obtido:

2021-10-09T08:59Z

Se eu alterar os dados de teste de "2021-10-09T08:59:00.00Z"para "2021-10-09T08:59:00.000Z", ele funcionará no Java 17. Alguma ideia de quais mudanças no Java 17 causaram falha?

Aparentemente, Gurobipy pode ler o índice de uma compreensão de lista formulada entre parênteses de uma função. Como é que isso funciona? Esta formulação não deveria passar um objeto gerador para a função? Como você lê o índice disso?

    md = gp.Model()
    md.addConstrs(True for i in [1,2,5,3])
    

A saída contém os índices que foram usados ​​na formulação de compreensão da lista:

{1: <gurobi.Constr *Awaiting Model Update*>,
 2: <gurobi.Constr *Awaiting Model Update*>,
 5: <gurobi.Constr *Awaiting Model Update*>,
 3: <gurobi.Constr *Awaiting Model Update*>}

Eu tenho uma função que calcula o hash de uma string literal:

inline consteval uint64_t HashLiteral(const char* key)
{
   // body not important here...
   return 0;
}

Em outra função, preciso da string literal e do hash que desejo calcular em tempo de compilação:

void function(const char* s)
{
   worker(s, HashLiteral(s));
}

No entanto, parece impossível fazer tal chamada function("string")e ter o hash calculado em seu corpo em tempo de compilação. O melhor que descobri agora é usar uma macro e redefinir a função:

#define MakeHashParms(s)   s,HashLiteral(s)
void function(const char* s, const uint64_t hash)
{
   worker(s, hash);
}
function(MakeHashParms("string"));

É possível uma solução mais direta?

Estou tentando projetar uma função simples como esta:

void draw(Callback callback)
{
    Drawing drawing("name");
    callback(drawing);

    std::cout << drawing.name() << std::endl;
}

onde drawingdeve ser passado para o retorno de chamada como referência, para que o chamador possa modificá-lo da seguinte forma:

draw([](auto& drawing) {
    drawing.set_name("another name");
});

Agora isso funciona, porque estou digitando explicitamente o parâmetro de retorno de chamada como auto&(ou Drawing&). Porém, quando apenas digito o parâmetro como auto(or Drawing), o código também compila, mas não funciona mais conforme o esperado. A drawinginstância é copiada em vez de passada por referência.

Gostaria que o código não fosse mais compilado quando o parâmetro lambda não fosse digitado explicitamente como referência.

Eu tentei o seguinte:

• using Callback = std::function<void(Drawing&)>;: drawingnão é modificado quando não é digitado explicitamente como auto&.
• template<typename T> concept Callback = std::is_invocable<void, T, Drawing&>;: o mesmo que acima.
• using Callback = void (*)(Drawing&);: isso realmente funciona, mas perco a capacidade de usar a captura.

Então, como faço para digitar Callback corretamente para que apenas Drawing&seja um parâmetro válido para o lambda?

Pelo que entendi, não deveria ser possível ter uma referência mutável a um dado imutável. Dessa forma, se eu quiser criar alguns structque implementem Iteratorcom base na mutação de um estado interno, terei que declarar qualquer instância disso structcomo mutável para poder criar as referências mutáveis ​​​​necessárias.

Para demonstrar, construí um exemplo simples, abaixo:

struct MyIter {
    internal_state: u32
}

impl MyIter {
    fn new() -> MyIter {
        MyIter{ internal_state: 0 }
    }
}

impl Iterator for MyIter {
    type Item = u32;
    fn next(&mut self) -> Option<u32> {
        self.internal_state += 1;
        Some(self.internal_state)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::iter::zip;

    #[test]
    fn mutable_declaration_no_zip() {
        let mut my_iter = MyIter::new();
        assert_eq!(my_iter.next(), Some(1));
        assert_eq!(my_iter.next(), Some(2));
        assert_eq!(my_iter.next(), Some(3));
    }
}

Isso compila bem e passa, enquanto se eu alterar a função de teste para ter uma declaração imutável for my_iter, como abaixo, ela se recusará a compilar com a mensagem esperada de error[E0596]: cannot borrow 'my_iter' as mutable, as it is not declared as mutable:

#[test]
fn immutable_declartaion_no_zip() {
    let my_iter = MyIter::new();
    assert_eq!(my_iter.next(), Some(1));
    assert_eq!(my_iter.next(), Some(2));
    assert_eq!(my_iter.next(), Some(3));
}

Minha pergunta diz respeito ao caso em que faço basicamente o mesmo que acima, mas uso std::iter::zippara realizar a iteração. O que acontece agora é que mesmo que eu declare my_itercomo imutável, o teste é compilado e aprovado, o que significa que nos bastidores ziphouve uma mutação no estado da variável imutável na qual passei!

#[test]
fn immutable_declaration_zip() {
    let my_iter = MyIter::new();
    let nums: [u32;10] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    for (i, num) in zip(my_iter, nums.iter()) {
        assert_eq!(i, *num);
    }
}

Então, alguém poderia explicar por que zipfoi configurado para poder fazer isso? Como posso zipchamar o next()método e, portanto, gerar referências mutáveis ​​para dados que declarei como imutáveis?

Eu tenho uma lista de vetores de tamanho livre

set.seed(1)
dat <- lapply(1:10, \(x) sample(letters, size = sample(1:10,1), replace = T))

dat

[[1]]
[1] "d" "g" "a" "b" "w" "k" "n" "r" "s"

[[2]]
[1] "u"

[[3]]
[1] "j" "v" "n" "j" "g"

[[4]]
[1] "o" "u" "e" "i" "y" "n" "e" "e" "b"

[[5]]
 [1] "y" "l" "o" "a" "t" "c" "f" "j" "j" "f"

Quais são algumas maneiras de fazer uma matriz densa como esta, mas de forma mais eficiente? Também gostaria de salvar os nomes das colunas como no exemplo

library(arules)
as(transactions(dat), "matrix")


          a     b     c     d     e     f     g     h     i     j     k     l     m
 [1,]  TRUE  TRUE FALSE  TRUE FALSE FALSE  TRUE FALSE FALSE FALSE  TRUE FALSE FALSE
 [2,] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
 [3,] FALSE FALSE FALSE FALSE FALSE FALSE  TRUE FALSE FALSE  TRUE FALSE FALSE FALSE
 [4,] FALSE  TRUE FALSE FALSE  TRUE FALSE FALSE FALSE  TRUE FALSE FALSE FALSE FALSE
 [5,]  TRUE FALSE  TRUE FALSE FALSE  TRUE FALSE FALSE FALSE  TRUE FALSE  TRUE FALSE
 [6,] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE  TRUE FALSE
 [7,] FALSE FALSE FALSE FALSE FALSE  TRUE FALSE  TRUE FALSE FALSE FALSE  TRUE FALSE
 [8,] FALSE FALSE FALSE FALSE FALSE  TRUE  TRUE FALSE FALSE  TRUE FALSE FALSE FALSE
 [9,] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE  TRUE
[10,]  TRUE FALSE FALSE FALSE FALSE  TRUE FALSE  TRUE FALSE FALSE FALSE FALSE FALSE
          n     o     r     s     t     u     v     w     x     y     z
 [1,]  TRUE FALSE  TRUE  TRUE FALSE FALSE FALSE  TRUE FALSE FALSE FALSE
 [2,] FALSE FALSE FALSE FALSE FALSE  TRUE FALSE FALSE FALSE FALSE FALSE
 [3,]  TRUE FALSE FALSE FALSE FALSE FALSE  TRUE FALSE FALSE FALSE FALSE
 [4,]  TRUE  TRUE FALSE FALSE FALSE  TRUE FALSE FALSE FALSE  TRUE FALSE
 [5,] FALSE  TRUE FALSE FALSE  TRUE FALSE FALSE FALSE FALSE  TRUE FALSE
 [6,] FALSE FALSE FALSE FALSE  TRUE FALSE FALSE FALSE FALSE  TRUE  TRUE
 [7,] FALSE FALSE FALSE FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE FALSE
 [8,] FALSE FALSE FALSE  TRUE FALSE FALSE FALSE FALSE  TRUE FALSE  TRUE
 [9,] FALSE FALSE  TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
[10,]  TRUE FALSE FALSE  TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE

Este é um exemplo do pacote аrules e não está otimizado para meus propósitos

Quero testar se uma string contém SOMENTE substrings específicas (como palavras inteiras)/espaços

Escrevi algum código e funciona, mas estou preocupado que não seja muito eficiente

Existe uma maneira mais eficiente de fazer isso?

Aqui está meu código ineficiente

const str1 = 'a♭ apple a a a a a apple   a♭ a' // valid
const str2 = 'a♭ apple a a a a a apple   a♭ aa' // invalid aa
const str3 = 'a♭ apple ad  a a a apple   a♭ a' // invalid ad

const allowedSubstrings = [
  'a', 'a♭', 'apple'
]

const isStringValid = str => {
  allowedSubstrings.forEach(sub => {
    // https://stackoverflow.com/a/6713427/1205871
    // regex for whole words only
    const strRegex = `(?<!\\S)${sub}(?!\\S)`
    const regex = new RegExp(strRegex, 'g')
    str = str.replace(regex, '')
  })
  str = str.replaceAll(' ', '')
  // console.log(str)
  return str === ''
}

console.log('str1', isStringValid(str1))
console.log('str2', isStringValid(str2))
console.log('str3', isStringValid(str3))