All perguntas(coding)

O código:

var primeCtr = con.Contractors?.Where(ctr => ctr.Type == "Prime").FirstOrDefault();
if (primeCtr == null)
   primeCtr = con.Contractors?.Where(ctr => ctr.Type == "Original Prime").FirstOrDefault();

Explicação: Se existir um contratante do tipo "Prime", use-o, caso contrário, use o "Original Prime"

Eu poderia ter codificado isso usando ? : expressão, mas acho que teria sido menos eficiente?

var primeCtr = con.Contractors?.Where(ctr => ctr.Type == "Prime").Any() ? con.Contractors?.Where(ctr => ctr.Type == "Prime").FirstOrDefault() : con.Contractors?.Where(ctr => ctr.Type == "Original Prime").FirstOrDefault();

A consulta para "Prime" seria executada duas vezes, eu acho?

Apenas tentando determinar se existe uma maneira mais elegante de expressar isso usando o EF Core 8? Este é meu primeiro aplicativo EF Core e não uso o EF antigo há vários anos, então pode estar enferrujado.

Eu tenho um arquivo com um identificador e um valor:

ABC123 111111
ABC123 111111
ABCDEF 333333
ABCDEF 111111
CCCCCC 333333
ABC123 222222
DEF123 444444
DEF123 444444

Ambas as colunas contêm valores duplicados, mas preciso contar linhas que tenham o mesmo ID (primeira coluna) e um valor exclusivo (segunda coluna). Isso tornaria a saída da entrada acima:

ABCDEF 2
ABC123 2
DEF123 1
CCCCCC 1

...onde a primeira coluna é o ID e a segunda coluna é a contagem de valores exclusivos na segunda coluna. Em outras palavras, preciso descobrir quantos valores únicos existem para um determinado ID .

O mais próximo que cheguei foi isso, mas tudo o que faz é contar os valores exclusivos da primeira coluna:

cut -d " " -f1 "file.txt" | uniq -cd | sort -nr | head

Como eu faria algo assim no Bash?

Para fins de descrição, forneço uma reprodução mínima do seguinte código:

#include <bits/stdc++.h>
#include <iostream>
#include <regex>
#include <string>
#include <string>
#include <Windows.h>

// GBK 转 UTF-8
std::string GBKToUTF8(const std::string& gbkStr) {
    // 1. 先将 GBK 转换为宽字符（UTF-16）// Convert GBK to wide characters first (UTF-16)
    int len = MultiByteToWideChar(CP_ACP, 0, gbkStr.c_str(), -1, nullptr, 0);
    std::wstring wstr(len, 0);
    MultiByteToWideChar(CP_ACP, 0, gbkStr.c_str(), -1, &wstr[0], len);

    // 2. 将宽字符（UTF-16）转换为 UTF-8 // Convert wide characters (UTF-16) to UTF-8
    len = WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), -1, nullptr, 0, nullptr, nullptr);
    std::string utf8Str(len, 0);
    WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), -1, &utf8Str[0], len, nullptr, nullptr);

    return utf8Str;
}

int main() {
    // 示例身份证号，长度为18 // Example ID number, length 18
    std::string id_number = GBKToUTF8("610702199404261983");  
    // 检查字符串长度 // Check string length
    std::cout << "Length before: " << id_number.length() << "\n"
        << id_number << std::endl;

    // 正则表达式 // Regular expression
    const std::regex id_number_pattern18("^([1-6][1-9]|50)\\d{4}(18|19|20)\\d{2}((0[1-9])|10|11|12)(([0-2][1-9])|10|20|30|31)\\d{3}[0-9Xx]$");

    // 进行匹配 // Make a match
    if (std::regex_match(id_number, id_number_pattern18)) {
        std::cout << "Match successful!" << std::endl;
    } else {
        std::cout << "Match failed!" << std::endl;
    }

    return 0;
}

O problema agora é que quando a id_numberstring é transcodificada em UTF-8 , o comprimento muda de 18 para 19 . Além disso, o regex não corresponde mais à string corretamente (ele pode ser correspondido corretamente se não for transcodificado).

Suspeito que a string foi transcodificada e alguns caracteres invisíveis foram adicionados, mas não sei como consertar isso.

Aqui estão algumas capturas de tela da depuração do VS2022 (ISO C++ 17) para referência (é claro, as capturas de tela não são do código de reprodução mínimo, mas devem ser bem compreendidas):

Antes da transcodificação

Após a transcodificação

Não sei como fazer isso no momento ou gostaria de fornecer uma solução e uma descrição de como o problema surge.

por exemplo, echo -e "\001\033[5m\033[7m\002${var}\001\033[0m\002" se o var estiver começando com um caractere não numérico, ele funciona. Porém, se a var começando com número falhar, por exemplo var = 5 então a string é "\001\033[5m\033[7m\0025\001\033[0m\002"` por algum motivo ela não piscará o 5 a tela tem uma linha em branco

Desculpe se formatei incorretamente ou se o título não está correto, sou novo em R e estouro de pilha. Estou trabalhando com uma lista (chamada climas) que possui 20 quadros de dados (de cada província), cada um com colunas de ano, mês, dia e temperatura (junto com outras coisas). Procuro encontrar as linhas onde a temperatura está acima de um determinado limite, mas esse limite muda para cada província. Consegui usar o lapply para encontrar o limite para cada província, mas quando tento usar esses limites para encontrar as linhas nos dados em que a temperatura está acima do limite, a saída não está correta. Meu código retorna vários números, mas eles não parecem estar relacionados ao fato de serem maiores que o limite, e também não sei como fazer com que ele retorne a linha inteira em vez de apenas o valor da temperatura.

exemplo de lista climática:

A <- data.frame("D" = c(1:30), "T" = c(sample(10:30, size = 30, replace = TRUE)))
B <- data.frame("D" = c(1:30), "T" = c(sample(4:22, size = 30, replace = TRUE)))
C <- data.frame("D" = c(1:30), "T" = c(sample(14:35, size = 30, replace = TRUE)))

climate <- list("Alist" = A, "Blist" = B, "Clist" = C)
climate

Eu usei lapply para encontrar o limite,

thresh95 <- lapply(lapply(
  climate, `[[`, 2), # this one takes my list of climate data and selects the T column for all provinces
  quantile, probs = c(0.95), na.rm = TRUE) # this one takes the previous list and finds 95th percentile value
thresh95

mas quando tento encontrar as temperaturas que estão acima do limite, algo dá errado.

tmax95 <-  lapply(lapply(climate, `[[`, 2), # this one takes my list of climate data and selects the T column for all provinces
  function(x) x[which(x>thresh95)])# this one takes my list of climate data and selects the temps that are greater than the threshold
tmax95

Existe uma maneira de escrever algo que retorne um subconjunto do quadro de dados de cada província onde a condição é que a temperatura seja maior que o limite? Obrigado!

Meu DataFrame é:

import pandas as pd 
df = pd.DataFrame(
    {
        'a': [20, 30, 2, 5, 10]
    }
)

A saída esperada é pct_change()de a:

    a  pct_change
0  20  -50.000000
1  30   50.000000
2   2  -93.333333
3   5  150.000000
4  10  100.000000

Quero comparar df.a.iloc[0]com 40 para o primeiro valor de pct_change. Se eu usar df['pct_change'] = df.a.pct_change().mul(100), o primeiro valor será NaN.

Minha tentativa:

def percent(a, b):
    result = ((a - b) / b) * 100
    return result.round(2)

df.loc[df.index[0], 'pct_change'] = percent(df.a.iloc[0], 40)

Existe uma maneira melhor/mais eficiente?

Estou implementando um algoritmo de localização de caminhos A* em C++ para resolver um labirinto, mas estou encontrando uma falha de segmentação (SIGSEGV) quando o tamanho do labirinto é alto (~10.000x10.000 ou maior).

O erro ocorre na ~__shared_count()função shared_ptr_base.hafter node = queue.top()é chamada na linha 58 e dezenas de ~Node()desconstrutores são chamados depois disso.

Editar: O erro realmente ocorre na _Sp_counted_base<_S_atomic>::_M_release()função agora, embora eu não saiba o que mudei.

Aqui estão as partes do meu código que devem ser relevantes. Sou novo no uso de ponteiros compartilhados, então não tenho certeza de qual é o problema ou como corrigi-lo.

principal.cpp

#include <iostream>
#include <queue>
#include <random>
#include <vector>
#include <algorithm>
#include <stack>
#include <fstream>

#include "Node.hpp"

constexpr uint16_t maze_size = 10000;

void solve(const uint16_t start_x, const uint16_t start_y, const uint16_t goal_x,
           const uint16_t goal_y,
           const std::vector<std::vector<std::pair<bool, bool> > > &walls) {
    std::vector<std::vector<bool> > visited(maze_size, std::vector<bool>(maze_size, false));

    // Min heap for our queue
    std::priority_queue<Node, std::vector<Node>, std::greater<> > queue;

    Node node(start_x, start_y, goal_x, goal_y);

    visited[node.x][node.y] = true;

    while (!node.solved(goal_x, goal_y)) {
        // Add all valid neighbors to the queue
        {
            const auto x = node.x;
            const auto y = node.y;
            const auto ptr = std::make_shared<Node>(node);
            // Right
            if (x < maze_size - 1 && !walls[x][y].first && !visited[x + 1][y]) {
                queue.emplace(x + 1, y, goal_x, goal_y, ptr);
                visited[x + 1][y] = true;
            }
            // Left
            if (x > 0 && !walls[x - 1][y].first && !visited[x - 1][y]) {
                queue.emplace(x - 1, y, goal_x, goal_y, ptr);
                visited[x - 1][y] = true;
            }
            // Down
            if (y < maze_size - 1 && !walls[x][y].second && !visited[x][y + 1]) {
                queue.emplace(x, y + 1, goal_x, goal_y, ptr);
                visited[x][y + 1] = true;
            }
            // Up
            if (y > 0 && !walls[x][y - 1].second && !visited[x][y - 1]) {
                queue.emplace(x, y - 1, goal_x, goal_y, ptr);
                visited[x][y - 1] = true;
            }
        }
        node = queue.top();
        queue.pop();
    }
}

Nó.hpp

#ifndef NODE_HPP
#define NODE_HPP

#include <cstdint>
#include <memory>

class Node {
public:
    uint16_t x, y;
    uint32_t steps;
    uint32_t value;

    std::shared_ptr<Node> parent;

    Node(const uint16_t x, const uint16_t y, const uint16_t goal_x, const uint16_t goal_y,
         const std::shared_ptr<Node> &parent = nullptr) : x(x), y(y), parent(parent) {
        steps = parent ? parent->steps + 1 : 0;
        value = abs(static_cast<int32_t>(goal_x) - static_cast<int32_t>(x)) +
                abs(static_cast<int32_t>(goal_y) - static_cast<int32_t>(y)) +
                steps;
    }

    [[nodiscard]] bool solved(const uint16_t goal_x, const uint16_t goal_y) const {
        return x == goal_x && y == goal_y;
    }

    // Overload the > operator for the priority queue
    bool operator>(const Node &rhs) const {
        if (value == rhs.value) {
            return steps < rhs.steps;
        }
        return value > rhs.value;
    }
};

#endif

Saída Valgrind

valgrind --leak-check=full ./Tests 
==5385== Memcheck, a memory error detector
==5385== Copyright (C) 2002-2022, and GNU GPL'd, by Julian Seward et al.
==5385== Using Valgrind-3.22.0 and LibVEX; rerun with -h for copyright info
==5385== Command: ./Tests
==5385== 
Maze loaded10000
==5385== Stack overflow in thread #1: can't grow stack to 0x1ffe801000
==5385== 
==5385== Process terminating with default action of signal 11 (SIGSEGV)
==5385==  Access not within mapped region at address 0x1FFE801FF8
==5385== Stack overflow in thread #1: can't grow stack to 0x1ffe801000
==5385==    at 0x116230: std::_Sp_counted_ptr_inplace<Node, std::allocator<void>, (__gnu_cxx::_Lock_policy)2>::_M_dispose() (shared_ptr_base.h:613)
==5385==  If you believe this happened as a result of a stack
==5385==  overflow in your program's main thread (unlikely but
==5385==  possible), you can try to increase the size of the
==5385==  main thread stack using the --main-stacksize= flag.
==5385==  The main thread stack size used in this run was 8388608.
==5385== 
==5385== HEAP SUMMARY:
==5385==     in use at exit: 239,026,864 bytes in 556,422 blocks
==5385==   total heap usage: 3,380,473 allocs, 2,824,051 frees, 374,594,816 bytes allocated
==5385== 
==5385== LEAK SUMMARY:
==5385==    definitely lost: 0 bytes in 0 blocks
==5385==    indirectly lost: 0 bytes in 0 blocks
==5385==      possibly lost: 0 bytes in 0 blocks
==5385==    still reachable: 239,026,864 bytes in 556,422 blocks
==5385==         suppressed: 0 bytes in 0 blocks
==5385== Reachable blocks (those to which a pointer was found) are not shown.
==5385== To see them, rerun with: --leak-check=full --show-leak-kinds=all
==5385== 
==5385== For lists of detected and suppressed errors, rerun with: -s
==5385== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
Segmentation fault (core dumped)

Você poderia tentar reproduzir o erro usando a seguinte função para carregar este arquivo labirinto . Desculpe pelo tamanho. Você pode carregá-lo usando esta função:

std::vector<std::vector<std::pair<bool, bool> > > readVectorFromFile(const std::string &filename) {
    std::vector<std::vector<std::pair<bool, bool> > > vec;
    std::ifstream inFile(filename, std::ios::binary);
    if (!inFile) {
        std::cerr << "Error opening file for reading: " << filename << std::endl;
        return vec;
    }

    // Read the size of the outer vector
    size_t outerSize;
    inFile.read(reinterpret_cast<char *>(&outerSize), sizeof(outerSize));

    vec.resize(outerSize);

    for (auto &innerVec: vec) {
        // Read the size of each inner vector
        size_t innerSize;
        inFile.read(reinterpret_cast<char *>(&innerSize), sizeof(innerSize));

        innerVec.resize(innerSize);

        // Read each pair in the inner vector
        for (auto &pair: innerVec) {
            inFile.read(reinterpret_cast<char *>(&pair.first), sizeof(bool));
            inFile.read(reinterpret_cast<char *>(&pair.second), sizeof(bool));
        }
    }

    inFile.close();
    return vec;
}

O principal seria algo como:

int main() {
    auto walls = readVectorFromFile("maze.dat");
    std::cout << "Maze loaded" << std::endl;

    solve(0, 0, maze_size - 1, maze_size - 1, walls);

    return 0;
}

Eu gostaria de usar comba função do Raku com uma regex de uma gramática em vez de uma regex independente. Por exemplo, no código a seguir, que analisa journalctllogs do stdin, gostaria de substituir &hin MAINpor algo como &Journalctl::full_log:

role Log {
  token preamble { ... };
  token message { <-preamble>* };
  regex full_log { <preamble> <message> };
}

grammar Journalctl does Log {
  token date { \S+\s\d\d\s\d\d\:\d\d\:\d\d};
  token hostname { \S* };
  token ctl_unit { <-[\[]>+ };
  token pid { \d+ };
  regex preamble { <date> <.ws> <hostname> <.ws> <ctl_unit> \[ <pid> \]\: };
}

sub MAIN( ) {
  my regex h { h. };
  for $*IN.comb(&h) -> $wof {  # FIXME
    say $wof;
  }
}

Aqui estão alguns exemplos journalctlde registros para referência:

Jun 25 14:45:54 cpu-hostname systemd-timesyncd[725]: Initial synchronization to time server 185.125.190.56:123 (ntp.ubuntu.com).
Jun 25 14:45:54 cpu-hostname systemd-resolved[722]: Clock change detected. Flushing caches.

Preciso converter uma lista (incluindo cabeçalhos) em um Dataframe.

Se eu fizer isso diretamente usando pl.DataFrame(list), os cabeçalhos são criados e tudo é mantido como uma string. Além disso, a tabela é transposta, de forma que o primeiro elemento da lista se torne a primeira coluna do dataframe.

Lista de entrada.

[
    ['Earnings estimate', 'Current qtr. (Jun 2024)', 'Next qtr. (Sep 2024)', 'Current year (2024)', 'Next year (2025)'],
    ['No. of analysts', '13', '11', '26', '26'],
    ['Avg. Estimate', '1.52', '1.62', '6.27', '7.23'],
    ['Low estimate', '1.36', '1.3', '5.02', '5.88'],
    ['High estimate', '1.61', '1.74', '6.66', '8.56'],
    ['Year ago EPS', '1.76', '1.36', '5.74', '6.27'],
]

Resultado esperado.

Recentemente, mudamos para um GCC mais recente e ele otimizou uma função inteira e a substituiu pelo código de armadilha "acesso ao ponteiro nulo" ao otimizar o tamanho. Olhando para godbolt, o problema apareceu com o GCC 11.1 ao otimizar com -Os. Otimizar com -O2e -O3funciona bem, mesmo com -fstrict-aliasing.

Simplificado, o código fica assim ( link godbolt ):

#include <inttypes.h>
#include <stddef.h>
#include <string.h>

typedef struct bounds_s {
  uint8_t *start;
  uint8_t *end;
} bounds_s_t;

static void reserve_space(bounds_s_t *bounds, size_t len, uint8_t **element)
{
  if (bounds->start + len > bounds->end) {
    return;
  }
  
  *element = bounds->start;
  bounds->start += len;
}

void bug(uint8_t *buffer, size_t size)
{
  bounds_s_t bounds;
  uint32_t *initialize_this;
  
  initialize_this = NULL;
  bounds.start = buffer;
  bounds.end = buffer + size;

  reserve_space(&bounds, sizeof(*initialize_this), (uint8_t **)&initialize_this);

  uint32_t value = 1234;
  memcpy(initialize_this, &value, sizeof(*initialize_this));
}

E leva à seguinte montagem:

bug:
        xor     eax, eax
        mov     DWORD PTR ds:0, eax
        ud2

Que otimização faz o GCC pensar que a initialize_thisvariável é NULL? A única coisa que me vem à mente é quebrar regras rígidas de alias. Mas será que a tipificação de ponteiros duplos pode uint32_t **realmente uint8_t **ser o problema aqui e levar a consequências tão pesadas?