AskOverflow.Dev

AskOverflow.Dev Logo AskOverflow.Dev Logo

AskOverflow.Dev Navigation

  • Início
  • system&network
  • Ubuntu
  • Unix
  • DBA
  • Computer
  • Coding
  • LangChain

Mobile menu

Close
  • Início
  • system&network
    • Recentes
    • Highest score
    • tags
  • Ubuntu
    • Recentes
    • Highest score
    • tags
  • Unix
    • Recentes
    • tags
  • DBA
    • Recentes
    • tags
  • Computer
    • Recentes
    • tags
  • Coding
    • Recentes
    • tags
Início / coding / 问题

All perguntas(coding)

Martin Hope
Stephen
Asked: 2025-04-28 23:29:02 +0800 CST

for-loop baseado em intervalo em C++ sobre std::optional<Container> não funciona

  • 10

Deixe-me começar com um C++código que simplifica os problemas que enfrentei na base de código real. Eu o compilei com --std=c++20e --std=c++17. O primeiro for-loop abaixo funcionou bem; o segundo for-loop, que retorna, std::optional<Container>não funcionou, para todos os contêineres que testei. Gostaria de entender o porquê:

#include <iostream>
#include <optional>
#include <string>
#include <unordered_set>

std::unordered_set<std::string> GenerateSet() {                                                                                                                                                                                                      
  std::unordered_set<std::string> names = {"a", "b"};                                                                                                                                                                                                
  return names;                                                                                                                                                                                                                                      
}

std::optional<std::unordered_set<std::string>> GenerateOptionalSet() {                                                                                                                                                                               
  std::unordered_set<std::string> names = {"a", "b"};                                                                                                                                                                                                
  return names;                                                                                                                                                                                                                                      
}

int main() {                                                                                                                                                                                                                                         
  std::cout << "When a set is returned: {";                                                                                                                                                                                                          
  for (const auto& e : GenerateSet()) {                                                                                                                                                                                                              
    std::cout << e << " ";                                                                                                                                                                                                                           
  }                                                                                                                                                                                                                                                  
  std::cout << "}" << std::endl;                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                     
  std::cout << "When a optional of a set is returned: {";                                                                                                                                                                                            
  for (const auto& e : GenerateOptionalSet().value()) {                                                                                                                                                                                              
    std::cout << e << " ";                                                                                                                                                                                                                           
  }                                                                                                                                                                                                                                                  
  std::cout << "}" << std::endl;                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                     
  return 0;                                                                                                                                                                                                                                          
}

O resultado foram falhas de segmentação em tempo de execução (bastante recente clang) ou nenhuma iteração no segundo for-loop (bastante antigo gccem uma máquina Linux arcaica).

Aqui está o URL ao qual me referi em relação a std::optional<T>::value(): std::optional::value() do cppreference.com

Parece haver 4 versões diferentes. Não tinha certeza de qual versão das 4 funções substituídas seria invocada e por que não funciona como eu esperava (ou seja, apenas repetindo o valor do temporary retornado std::optional<T>).

c++
  • 1 respostas
  • 127 Views
Martin Hope
Bogaso
Asked: 2025-04-26 02:20:01 +0800 CST

Método eficiente para estimar a composição do grupo

  • 10

Abaixo está o código para estimar a associação de grupo de cada elemento de um grande vetor

Interval = data.frame(lowerLimit = c(0, c(13.31, 14.1, 14.52, 15.9, 17.88, 20.85, 22.14, 22.6, 23.49, 
24.31, 26.54, 27.29, 32.41, 33.49, 35.08, 38.25, 41.84, 46, 47.35, 
47.85, 48.13, 48.25, 48.8, 50.83, 51.55, 53.22, 54.21, 55.94, 
56.31, 58.09, 58.35, 59.92, 60.78, 64.9, 68.7, 72.79, 77.27, 
78.38, 79.04, 80.61, 85.52, 86.25, 86.63, 88.05, 90.07, 90.25, 
95.13, 96.88, 98.47, 99.77)), upperLimit = c(13.31, 14.1, 14.52, 15.9, 17.88, 20.85, 22.14, 22.6, 23.49, 
24.31, 26.54, 27.29, 32.41, 33.49, 35.08, 38.25, 41.84, 46, 47.35, 
47.85, 48.13, 48.25, 48.8, 50.83, 51.55, 53.22, 54.21, 55.94, 
56.31, 58.09, 58.35, 59.92, 60.78, 64.9, 68.7, 72.79, 77.27, 
78.38, 79.04, 80.61, 85.52, 86.25, 86.63, 88.05, 90.07, 90.25, 
95.13, 96.88, 98.47, 99.77, 100))

set.seed(1)
Num = runif(100000, 0, 100)
sapply(Num, function(i) which(Interval$lowerLimit <= i & Interval$upperLimit > i))

Embora o código acima possa estimar a associação de grupo para cada elemento de Num, gostaria de saber se existe algum método mais eficiente e rápido disponível. Para vetores grandes, este código está demorando muito.

Muito obrigado pela sua sugestão.

  • 4 respostas
  • 128 Views
Martin Hope
Newton's in-law
Asked: 2025-04-25 15:08:32 +0800 CST

Os arquivos C padrão são compilados?

  • 10

Sempre que criamos um arquivo com definições de funções personalizadas, por exemplo, utils.ce seu arquivo de cabeçalho correspondente utils.hcontendo as declarações de função, preciso compilar o utils.carquivo junto com o código do driver em que estou usando, com um comando como gcc driver.c utils.c -o my_exe.

Então, qual instrução compila os arquivos C padrão, cujos arquivos de cabeçalho incluímos como stdio.h?

c
  • 5 respostas
  • 156 Views
Martin Hope
Ben
Asked: 2025-04-25 11:35:24 +0800 CST

COUNTIFS do UNIQUE VSTACK

  • 10

Tenho uma tabela na qual quero contar quantas ocorrências de valores existem em duas colunas, com base no valor de uma terceira, e para facilitar a leitura, quero poder ver esses valores exclusivos com a contagem ao lado deles.

Por exemplo:

Pessoa1 Pessoa2 Número
Conta Dave 2
Dave John 2
John Conta 1

Quero ver quantas vezes o nome de cada pessoa aparece, com base no valor da terceira coluna. Como este é um documento fluido, as únicas colunas atualizadas são essas três, então quero uma nova coluna com os valores únicos de A e B, se o valor de C = 2.

O que eu descobri até agora é:

=UNIQUE(VSTACK(A2:A100,B2:B100))

O que funciona bem, mas contar as ocorrências com base no valor de C é onde estou tropeçando. Eu tentei

=COUNTIFS(A2:B100,E2,C2:C100,">1")

Mas ele continua apresentando a mensagem "Um valor é o tipo de dado errado". Eu me certifiquei de que as colunas são do tipo correto, por exemplo, C é um número, e também copiei os valores da função UNIQUE para uma coluna separada, para que ele não tente empilhar funções.

Tentei outras funções como, COUNT(UNIQUE(FILTER())mas isso não elimina as contagens inválidas, e outra solução, não sei se funciona porque não consigo entender a função:

=SUM(--(FREQUENCY(IF(C2:C18=2,MATCH(A2:A18,B2:B18,0)),ROW(A2:B18)-ROW(A2)+1)>1))
excel
  • 4 respostas
  • 72 Views
Martin Hope
Enlico
Asked: 2025-04-24 14:30:40 +0800 CST

Por que a pesquisa de nome não qualificado de um nome dependente não encontra um lambda declarado entre a declaração do modelo e a instanciação?

  • 10

O programa a seguir está incorreto ,

inline constexpr auto makeFoo = [](auto const& x) {
    return getFoo(x);
};

inline constexpr auto getFoo = [](int const&) {
    return 1;
};

int bar() {
    return makeFoo(32);
}

e reverter as definições de makeFooe getFootorna-o correto .

Entendo que, com base no entendimento "informal" da pesquisa de nomes em duas fases:

  • makeFooé um lambda genérico e, getFooem seu corpo, é invocado em um argumento cujo tipo ainda não é conhecido, então o nome getFooainda não pode ser consultado;
  • quando a chamada makeFoo(32)é vista, o lambda operator()é intantiado com auto = int, então a busca de segunda fase pelo nome não qualificado getFooacontece;
  • isso, no entanto, é apenas ADL, então não encontra getFoo, porque esse é o nome de um lambda, ou seja, um objeto, não de uma função.

Alguém pode me orientar sobre as partes do rascunho padrão que "espelham" a explicação acima?

Suponho que [basic.lookup.unqual] e [temp.dep.res] possivelmente contenham tudo o que é necessário para explicar o caso, mas não consigo juntar as peças.

c++
  • 2 respostas
  • 179 Views
Martin Hope
Георгий Гуминов
Asked: 2025-04-22 09:41:22 +0800 CST

Qual é a categoria do iterador iota_view?

  • 10

Eu estava experimentando com std::iterator_traitsand std::views::iota. E de repente descobri que std::iterator_traitsreturn unexpected type para uma categoria de iterador.

libc++:

#include <ranges>

int main() {
    auto view = std::views::iota(0ULL, 10000000000ULL);

    static_assert(
      std::is_same_v<
        std::iterator_traits<decltype(view.begin())>::iterator_category
      , std::input_iterator_tag>
    );
}

libstdc++:

#include <ranges>

int main() {
    auto view = std::views::iota(0ULL, 10000000000ULL);

    static_assert(
      std::is_same_v<
        std::iterator_traits<decltype(view.begin())>::iterator_category
      , std::output_iterator_tag>
    );
}

Qual a razão para isso? Por que a categoria de características difere de std::random_access_tag?

c++
  • 2 respostas
  • 113 Views
Martin Hope
TheJanzap
Asked: 2025-04-20 16:00:26 +0800 CST

Por que uma função constexpr recursiva é muito mais rápida com parâmetros de referência do que com valores?

  • 10

Tenho a seguinte constexprfunção de Fibonacci:

constexpr auto fibo(unsigned int number) -> unsigned long long {
    if (number < 2) return number;
    return fibo(number - 1) + fibo(number - 2);
}

Se eu comparar com o código abaixo, obtenho a seguinte saída:

benchmark name                       samples       iterations    est run time
                                     mean          low mean      high mean
                                     std dev       low std dev   high std dev
-------------------------------------------------------------------------------
Benchmark fibo(46)                             100             1        2.66 m 
                                         1.60356 s     1.60231 s     1.60477 s 
                                        6.30399 ms    5.51902 ms    7.32077 ms

Quando altero o numberparâmetro para unsigned int const &number, a velocidade melhora significativamente:

benchmark name                       samples       iterations    est run time
                                     mean          low mean      high mean
                                     std dev       low std dev   high std dev
-------------------------------------------------------------------------------
Benchmark fibo(46)                             100             1    17.7672 ms 
                                        177.013 us    176.272 us      177.9 us 
                                        4.13731 us    3.56318 us    4.80496 us

Por que há um aumento tão grande de velocidade ao passar o parâmetro por referência?

Código de benchmarking:

#include "Fibonacci.hpp"
#include "catch2/catch_message.hpp"

#include <catch2/benchmark/catch_benchmark.hpp>
#include <catch2/catch_test_macros.hpp>
#include <catch2/generators/catch_generators.hpp>
#include <catch2/generators/catch_generators_all.hpp>
#include <catch2/generators/catch_generators_range.hpp>
#include <sstream>
#include <utility>

TEST_CASE("Fibonacci calculation", "[Fibonacci Benchmark Suite]") {
  auto entry = GENERATE(table<unsigned long long, unsigned long long>({
    {0, 0}, 
    {1, 1}, 
    {2, 1}, 
    {3, 2}, 
    {4, 3}, 
    {5, 5}, 
    {46, 1836311903} // Runs long!
    }));
  auto input = std::get<0>(entry);
  auto expected = std::get<1>(entry);
  std::ostringstream oss;
  oss << "Benchmark fibo(" << input << ")";
  auto benchmarkName = oss.str();
  BENCHMARK(std::move(benchmarkName)) {
    return fibo(input);
  };
  CAPTURE(input, expected);
  REQUIRE(fibo(input) == expected);
}

(Nota: Este código também parece um pouco estranho, já que a compilação com o GCC 14.2.1 às vezes fazia com que ele consumisse toda a minha RAM antes de ser morto pelo kernel do Linux. Adicionei os sinalizadores -fconstexpr-ops-limit=100000000000000e -fconstexpr-cache-depth=50, mas eles não parecem ter ajudado)

c++
  • 1 respostas
  • 148 Views
Martin Hope
pomatomus
Asked: 2023-10-04 14:50:16 +0800 CST

Como combinar dois mapas em R?

  • 11

Preciso de sua ajuda e forneci os códigos de exemplo abaixo. Meu problema envolve colocar 'map2' em um quadrado no canto superior esquerdo de 'map1' e adicionar uma seta de 'map2' para um local específico em 'map1'. Pesquisei no site, mas os tópicos mais discutidos estão relacionados à fusão de duas camadas de dados.

Se você puder me ajudar, eu agradeceria muito.

library (tidyverse)
 library (rnaturalearth)
 world <- rnaturalearth::ne_countries(scale = "medium", returnclass = "sf")
 
 map1<- ggplot(data = world) +
   geom_sf() +
   #annotation_scale(location = "bl", width_hint = 0.2) +
   #annotation_north_arrow(location = "tr", which_north = "true", 
   #                     pad_x = unit(0.83, "in"), pad_y = unit(0.02, "in"),
   #                   style = north_arrow_fancy_orienteering) +
   coord_sf(xlim = c(35, 48), ylim=c(12, 22))+
   xlab("Longtitude")+
   ylab("Latitude")
 
  

 map2<- ggplot(data = world) +
   geom_sf() +
   #annotation_scale(location = "bl", width_hint = 0.2) +
   #annotation_north_arrow(location = "tr", which_north = "true", 
   #                     pad_x = unit(0.83, "in"), pad_y = unit(0.02, "in"),
   #                   style = north_arrow_fancy_orienteering) +
   coord_sf(xlim = c(5, 45), ylim=c(5, 45))+
   xlab("Longtitude")+
   ylab("Latitude")

 map2 
  • 6 respostas
  • 109 Views
Martin Hope
Saplyn
Asked: 2023-08-24 21:19:32 +0800 CST

Rust, como copiar o valor interno de Rc<RefCell<T>> e retorná-lo?

  • 11

Resumo : sou novo no Rust, então decidi praticar implementando uma lista duplamente vinculada. Para fins de depuração, implementei o get()método, mas não consegui copiar o valor de um arquivo Rc<RefCell<_>>. (Desculpe por fazer pergunta idiota)

Problema : Estou tentando retornar um Result<T, &'static str>in .get()onde Té o tipo de dados armazenados no nó e &stré a string da mensagem de erro. O verificador de empréstimo me diz que não posso retornar uma referência a uma variável do método, então tentei copiar o valor interno e devolvê-lo, mas não consegui.

Código fonte :

use std::{rc::Rc, cell::RefCell};

struct Node<T> {
    data: Option<T>,
    prev: Option<Rc<RefCell<Node<T>>>>,
    next: Option<Rc<RefCell<Node<T>>>>,
}

impl<T> Node<T> {
    /// Instantiate a new dummy node.
    /// This node is used to mark the start and end of the list.
    /// It is not counted in the size of the list.
    fn new() -> Self {
        Node {
            data: None,
            prev: None,
            next: None,
        }
    }
    /// Instantiate a new content node.
    /// This node is used to store data.
    /// It is counted in the size of the list.
    fn from(data: T) -> Self {
        Node {
            data: Some(data),
            prev: None,
            next: None,
        }
    }
}

struct List<T> {
    head: Rc<RefCell<Node<T>>>,
    tail: Rc<RefCell<Node<T>>>,
    size: usize,
}

impl<T> List<T> {
    pub fn new() -> Self {
        let head = Rc::new(RefCell::new(Node::new()));
        let tail = Rc::new(RefCell::new(Node::new()));
        head.borrow_mut().next = Some(Rc::clone(&tail));
        tail.borrow_mut().prev = Some(Rc::clone(&head));
        List { head, tail, size: 0 }
    }
    pub fn prepend(&self, data: T) {
        let node = Rc::new(RefCell::new(Node::from(data)));
        let mut head = self.head.borrow_mut();
        
        node.borrow_mut().next = Some(head.next.take().unwrap());
        node.borrow_mut().prev = Some(Rc::clone(&self.head));
        head.next = Some(Rc::clone(&node));
        if let Some(next) = node.borrow().next.as_ref() {
            next.borrow_mut().prev = Some(Rc::clone(&node));
        };
    }
    pub fn append(&self, data: T) {
        let node = Rc::new(RefCell::new(Node::from(data)));
        let mut tail = self.tail.borrow_mut();
        
        node.borrow_mut().prev = Some(Rc::clone(&tail.prev.take().unwrap()));
        node.borrow_mut().next = Some(Rc::clone(&self.tail));
        tail.prev = Some(Rc::clone(&node));
        if let Some(prev) = node.borrow().prev.as_ref() {
            prev.borrow_mut().next = Some(Rc::clone(&node));
        };
    }
    pub fn get(&self, index: isize) -> Result<T, &'static str> {
        let mut current: Rc<RefCell<Node<T>>> = Rc::clone(self.head.borrow().next.as_ref().unwrap());
        for _ in 0..index {
            let tmp = Rc::clone(current.borrow().next.as_ref().ok_or("Index out of range")?);
            current = tmp;
        }
        let result = current.borrow().data.as_ref().ok_or("Index out of range")?;  // error[E0716]
        Ok(*result)  // error[E0507]
    }
}
/*
error[E0716]: temporary value dropped while borrowed
  --> src\linked.rs:74:22
   |
74 |         let result = current.borrow().data.as_ref().ok_or("Index out of range")?;
   |                      ^^^^^^^^^^^^^^^^                                           - temporary value is freed at the end of this statement
   |                      |
   |                      creates a temporary value which is freed while still in use
75 |         Ok(*result)
   |            ------- borrow later used here
   |
help: consider using a `let` binding to create a longer lived value
   |
74 ~         let binding = current.borrow();
75 ~         let result = binding.data.as_ref().ok_or("Index out of range")?;
   |

error[E0507]: cannot move out of `*result` which is behind a shared reference
  --> src\linked.rs:75:12
   |
75 |         Ok(*result)
   |            ^^^^^^^ move occurs because `*result` has type `T`, which does not implement the `Copy` trait
*/

Eu tentei :

  • Este post é sobre como fazer uma referência em value , mas é isso que estou tentando fazer e falhei.
  • Este post sobre como modificar umRefCell , mas isso não ajudou. Eu estava tentando devolvê-lo, não transformá-lo.
  • Este post é sobre como pegar um empréstimoRefCell , mas não consigo devolver o valor emprestado porque o emprestado Rctem vida curta (mas o valor interno não).
  • Este post sobre como retornar algo dentro de aRefCell e este post sobre como devolvê-lo com.map() , mas o compilador diz "trait vinculado não satisfeito" quando tentei usar .into()e emprestar o verificador reclama "não é possível sair" se eu remover o .into().
  • Este post é sobre o uso deRc::try_unwarp() , mas não funcionará, pois os dados internos têm mais de um proprietário.

Além disso : posso ter feito isso errado, por favor, perdoe-me se uma das postagens resolveu meu problema, mas eu não o implementei da maneira certa e, por favor, me ensine como fazê-lo corretamente. Muito obrigado.

rust
  • 2 respostas
  • 36 Views
Martin Hope
rima
Asked: 2023-08-19 12:47:17 +0800 CST

extrair informações de um dataframe em Python

  • 11

Suponha que eu tenha um conjunto de dados contendo informações sobre clientes de uma loja online. Esse conjunto de dados inclui colunas como nome do cliente, produto adquirido, data da compra, valor do pagamento e a província onde os clientes residem. Desejo criar um relatório analítico que mostre o valor total do pagamento com base nas províncias e um gráfico que represente o número de compras a cada mês.

insira a descrição da imagem aqui

Eu usei a operação de agrupamento e não obtive nenhum resultado.

python
  • 1 respostas
  • 52 Views
Prev
Próximo

Sidebar

Stats

  • Perguntas 205573
  • respostas 270741
  • best respostas 135370
  • utilizador 68524
  • Highest score
  • respostas
  • Marko Smith

    Reformatar números, inserindo separadores em posições fixas

    • 6 respostas
  • Marko Smith

    Por que os conceitos do C++20 causam erros de restrição cíclica, enquanto o SFINAE antigo não?

    • 2 respostas
  • Marko Smith

    Problema com extensão desinstalada automaticamente do VScode (tema Material)

    • 2 respostas
  • Marko Smith

    Vue 3: Erro na criação "Identificador esperado, mas encontrado 'import'" [duplicado]

    • 1 respostas
  • Marko Smith

    Qual é o propósito de `enum class` com um tipo subjacente especificado, mas sem enumeradores?

    • 1 respostas
  • Marko Smith

    Como faço para corrigir um erro MODULE_NOT_FOUND para um módulo que não importei manualmente?

    • 6 respostas
  • Marko Smith

    `(expression, lvalue) = rvalue` é uma atribuição válida em C ou C++? Por que alguns compiladores aceitam/rejeitam isso?

    • 3 respostas
  • Marko Smith

    Um programa vazio que não faz nada em C++ precisa de um heap de 204 KB, mas não em C

    • 1 respostas
  • Marko Smith

    PowerBI atualmente quebrado com BigQuery: problema de driver Simba com atualização do Windows

    • 2 respostas
  • Marko Smith

    AdMob: MobileAds.initialize() - "java.lang.Integer não pode ser convertido em java.lang.String" para alguns dispositivos

    • 1 respostas
  • Martin Hope
    Fantastic Mr Fox Somente o tipo copiável não é aceito na implementação std::vector do MSVC 2025-04-23 06:40:49 +0800 CST
  • Martin Hope
    Howard Hinnant Encontre o próximo dia da semana usando o cronógrafo 2025-04-21 08:30:25 +0800 CST
  • Martin Hope
    Fedor O inicializador de membro do construtor pode incluir a inicialização de outro membro? 2025-04-15 01:01:44 +0800 CST
  • Martin Hope
    Petr Filipský Por que os conceitos do C++20 causam erros de restrição cíclica, enquanto o SFINAE antigo não? 2025-03-23 21:39:40 +0800 CST
  • Martin Hope
    Catskul O C++20 mudou para permitir a conversão de `type(&)[N]` de matriz de limites conhecidos para `type(&)[]` de matriz de limites desconhecidos? 2025-03-04 06:57:53 +0800 CST
  • Martin Hope
    Stefan Pochmann Como/por que {2,3,10} e {x,3,10} com x=2 são ordenados de forma diferente? 2025-01-13 23:24:07 +0800 CST
  • Martin Hope
    Chad Feller O ponto e vírgula agora é opcional em condicionais bash com [[ .. ]] na versão 5.2? 2024-10-21 05:50:33 +0800 CST
  • Martin Hope
    Wrench Por que um traço duplo (--) faz com que esta cláusula MariaDB seja avaliada como verdadeira? 2024-05-05 13:37:20 +0800 CST
  • Martin Hope
    Waket Zheng Por que `dict(id=1, **{'id': 2})` às vezes gera `KeyError: 'id'` em vez de um TypeError? 2024-05-04 14:19:19 +0800 CST
  • Martin Hope
    user924 AdMob: MobileAds.initialize() - "java.lang.Integer não pode ser convertido em java.lang.String" para alguns dispositivos 2024-03-20 03:12:31 +0800 CST

Hot tag

python javascript c++ c# java typescript sql reactjs html

Explore

  • Início
  • Perguntas
    • Recentes
    • Highest score
  • tag
  • help

Footer

AskOverflow.Dev

About Us

  • About Us
  • Contact Us

Legal Stuff

  • Privacy Policy

Language

  • Pt
  • Server
  • Unix

© 2023 AskOverflow.DEV All Rights Reserve