All perguntas(coding)

É seguro usar uma variável estática de escopo de namespace (ou seja, ligação interna) como parâmetro padrão para uma função declarada em um cabeçalho? E se sim, é garantido que ao fazer uma chamada padrão em uma determinada unidade de tradução, o valor definido naquela unidade de tradução seja usado como padrão?

Em código:

biblioteca.h:

#pragma once

#ifdef USE_ALTERNATE_DEFAULT
static const int defaultValue = 42;
#else
static const int defaultValue = 314;
#endif

void printValue(int value = defaultValue);

biblioteca.cpp:

#include "lib.h"

#include <print>

void printValue(const int value) {
  std::println("Value: {}", value);
}

a.cpp:

#include "lib.h"

void foo() {
  printValue(); // '314'
  printValue(0); // '0'
}

b.cpp:

#define USE_ALTERNATE_DEFAULT

#include "lib.h"

void bar() {
  printValue(); // '42'
  printValue(1); // '1'
}

O código acima está bem formado? E é garantido que cada uma das chamadas para printValueresulte no valor no comentário correspondente sendo impresso?

Tenha em mente que lib.cpp, a.cpp e b.cpp podem fazer parte de diferentes bibliotecas/binários compartilhados.

O objetivo aqui é tornar o comportamento padrão de uma função personalizável em um nível por TU alterando as diretivas do pré-processador.

Contexto para a pergunta

Dito isto, a solução parece um tanto complicada e este pode ser um problema XY.

Aqui está uma descrição mais completa do que estou tentando fazer:

• Estou usando algo semelhante para bin2cgerar vários arquivos de cabeçalho que definem várias strings longas diferentes.
• Tenho uma biblioteca vinculada estaticamente libque precisa executar alguma operação nessas strings geradas automaticamente ou retornar à operação em uma string padrão caso nenhum cabeçalho desse tipo esteja disponível.
• Estou compilando várias versões diferentes de vários binários diferentes, cada um com diferentes arquivos de cabeçalho gerados automaticamente, cada um vinculado à lib.

Então lib.hpode ser algo como:

#ifdef GENERATED_HEADER
// static const char* kMyString defined in the generated header
#include GENERATED_HEADER
#else
// Define fall-back default.
static const char* kMyString = "default";
#endif

void doStuff(int someArg, const char* str = kMyString);

E claro lib.cpptem a definição de doStuff. Suponha que esta seja uma função complexa.

Então my_app1.cpp:

#include "lib.h"

int main() {
  int someArg = foo();
  doStuff(someArg);
}

E my_app2.cpp:

#include "lib.h"

int main() {
  int someArg = bar();
  doStuff(someArg);
}

Então:

• Compilar lib.cppem lib.a.
• Gerar Doc1.husando doc1.txtbin2c-ish.
• Gerar Doc2.husando doc2.txtbin2c-ish.
• Gerar Doc3.husando doc3.txtbin2c-ish.
• Compilar my_app1.cppe my_app1_default.avincular com lib.ainto my_app1_default.
• Compilar my_app1.cppcom -DGENERATED_HEADER=\"Doc1.h\"into my_app2_doc1.ae vincular com lib.ainto my_app1_doc1.
• Compilar my_app1.cppcom -DGENERATED_HEADER=\"Doc2.h\"into my_app1_doc2.ae vincular com lib.ainto my_app1_doc2.
• Compilar my_app2.cppe my_app2_default.avincular com lib.ainto my_app2_default.
• Compilar my_app2.cppcom -DGENERATED_HEADER=\"Doc3.h\"into my_app2_doc3.ae vincular com lib.ainto my_app2_doc3.

O ponto é que o comportamento de libpode ser personalizado em um nível por binário com base no ambiente de construção, enquanto ainda mantém uma única implementação de lib. E, além disso, libpode ser usado em vários códigos-fonte de aplicativos diferentes com código boilerplate mínimo.

Claro, se a abordagem do argumento padrão for malformada, aproximadamente a mesma coisa ainda pode ser alcançada simplesmente passando explicitamente a variável estática para a função. Mas isso exigiria um pouco mais de boilerplate no local da chamada, o que estou tentando evitar. Daí a pergunta acima :)

Estou tentando compor meu próprio componente Combobox usando Shadcn ui. Ao fazer isso, estou usando o componente Command .

Estou tentando vincular meu valor de entrada de comando ao estado do React no componente cliente Next.js assim:

const [customerQuery, setCustomerQuery] = useState("");

return <CommandInput
     placeholder="[email protected]"
     value={customerQuery}
     onChange={(e: any) => setCustomerQuery(e.target.value)}
     spellCheck={false}
/>

Na verdade, recebo um erro de tipo no onChangemanipulador:

Type '{ placeholder: string; value: string; onChange: (e: any) => void; spellCheck: false; }' is not assignable to type 'IntrinsicAttributes & Omit<Pick<Pick<DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof InputHTMLAttributes<...>> & { ...; } & { ...; }, "key" | ... 1 more ... | keyof InputHTMLAttributes<...>>, "type" | ... 1 more ... | "onChange"> & { ...; } & RefAttributes<...>'.
  Property 'onChange' does not exist on type 'IntrinsicAttributes & Omit<Pick<Pick<DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof InputHTMLAttributes<...>> & { ...; } & { ...; }, "key" | ... 1 more ... | keyof InputHTMLAttributes<...>>, "type" | ... 1 more ... | "onChange"> & { ...; } & RefAttributes<...>'. ts(2322)

Isso seria bom de consertar. Mas um problema maior é que ao digitar no campo de entrada nada acontece, nenhum texto aparece, nada. Vincular assim funciona para uma entrada regular, mas não parece funcionar na entrada do cmdk. Não recebo erros no console. As ferramentas de desenvolvimento do React não mostram nenhuma atualização no computador. Não vejo nenhum problema relacionado no Github do cmdk.

Se ajudar, aqui está o que o React devtools mostra:

Como posso consertar isso?

Tenho uma tabela chamada Query 2no Power BI.

A coluna total_counté o que estou tentando realizar, não é uma coluna real nos dados e precisará ser calculada. Ela é calculada com base na combinação de record_id, activity e end_date. Quando uma dessas três colunas muda, ela deve contar como uma. Se esses valores ainda forem os mesmos na próxima linha, a contagem não deve mudar e essa linha permanecer em branco, mas se um dos valores na próxima linha mudar, a contagem deve aumentar. Eu tentei o seguinte código e está próximo:

Total_Count =
VAR CurrentRow =
'Query2'[record_id] & "-" & 'Query2'[Activity] & "-" & 'Query2'[end_date] & "-" &   'Query2'[duration]
VAR PreviousRows =
FILTER(
    'Query2',
    'Query2'[record_id] & "-" & 'Query2'[Activity] & "-" & 'Query2'[end_date] & "-" & 'Query2'[duration] < CurrentRow
)
   RETURN
IF(
    RANKX(
        FILTER(
            'Query2',
            'Query2'[record_id] = EARLIER('Query2'[record_id]) &&
            'Query2'[Activity] = EARLIER('Query2'[Activity]) &&
            'Query2'[end_date] = EARLIER('Query2'[end_date]) &&
            'Query2'[duration] = EARLIER('Query2'[duration])
        ),
        'Query2'[start_date],
        ,
        ASC,
        DENSE
    ) = 1,
    COUNTROWS(PreviousRows) + 1,
    BLANK()
)

A contagem dá errado depois da primeira repetição, onde eu tenho 4 no meu total_count, eu tenho 6.

Tenho uma ferramenta de busca no meu site que faz tanto buscas tradicionais de texto completo quanto buscas usando embeddings. Por exemplo, quando você pesquisa "balão vermelho", quero resultados de texto e imagem. O problema é que nem todos os termos de busca fazem sentido para a detecção de objetos (como "William" ou mesmo um identificador, como o número da carteira de motorista). Sei que existem bibliotecas que me dizem se uma palavra é um substantivo, mas existe alguma que me diga se uma frase é pesquisável? Assim:

• Maçã Vermelha SIM
• Grande Ideia Não
• Carteira de Habilitação SIM
• Licença suspensa nº

Estou tentando ler várias tabelas compactadas com mais de 5 GB de tamanho em R e, como não tenho memória suficiente para lê-las todas de uma vez, preciso processá-las um pedaço de cada vez, por exemplo, as primeiras 1.000 linhas de cada arquivo, depois as próximas 1.000 linhas de cada arquivo, etc. Sei como manter um arquivo aberto com um cursor ou ponteiro de arquivo salvo basicamente em qualquer linguagem diferente de R. Como posso fazer isso aqui?

Atualmente estou fazendo algo parecido com isto:

library(data.table)
library(R.utils)

inFiles = c("file1.tsv.gz", "file2.tsv.gz", "file3.tsv.gz")
totallines <- 10000
chunksize <- 1000

iters          <- 1
skip_val       <- 0
max_iters      <- ceiling(totallines/chunksize)

while (iters <= max_iters) {

    
    data = lapply(inFiles,function(file) {
      data.table::fread(file, nrows=chunksize, skip=skip_val,
                        col.names=data_colnames, sep="\t")
    })

    # Process the data in omitted code here

    # Move on to the next chunk
    iters    = iters + 1
    skip_val = skip_val + chunksize
}

O problema é que esses arquivos são grandes e compactados, e quanto menor o chunksize ou maior o arquivo, o programa gasta mais e mais tempo apenas lendo por causa das linhas puladas. Toda vez que ele lê o próximo chunk, ele também tem que descompactar e pular todas as linhas anteriores.

Dei uma olhada em readr::read_delim_chunked , mas não tenho certeza de como poderia usá-lo para iterar por muitos arquivos de uma vez.

OK, então isso é mais um exercício de "otimização" de código.

Tenho que mover todos os elementos de um dicionário python para outro, sob certas condições, enquanto esvazio o dicionário de origem ao mesmo tempo. (Não importa se eu encontro elementos correspondentes ou não, o dicionário de origem deve estar vazio no final)

Vamos ter:

pie={"A1":{2000,2001,2002},"A2":{2003,2004,2005},"A3":{2000,2004,2007}} ; slices={}
condition_check=2000

Como eu disse, eu precisava mover os elementos para o dict de destino somente quando eles atendessem a uma certa condição. A correspondência é feita em chaves e/ou valores enquanto esvazia o dict de origem, e então eu comecei com este código (nesse caso a condição é em valores):

while bool(pie):
    temp = pie.popitem()
    if (condition_check in temp[1]): slices.update({temp[0]:temp[1]})

Agora a questão é: existe uma maneira de fazer isso sem a temp = pie.popitem()linha? (Pensei que talvez fosse possível usar uma expressão de atribuição para colocá-la dentro da ifcondição, talvez?)

PS Eu sei que poderia ir com

for s in [{k:v} for k,v in pie.items() if (condition_check in v)]: slices.update(s)
pie.clear()

ou, alternativamente

s = {k:v for k,v in pie.items() if (condition_check in v)} ; slices.update(s)
pie.clear()

Por fim, acho que slices.update({k:v for k,v in pie.items() if (condition_check in v)}) ; pie.clear()poderia servir bem

Ainda assim, eu gostaria de otimizar o primeiro código de forma a "mover/mesclar" a temp = pie.popitem()atribuição dentro da ifcondição de alguma forma... E estou curioso para saber se é possível conseguir algo assim de qualquer maneira, para ser sincero.

EDITAR:

Como @KellyBundy observou nos comentários: de fato, a coisa a realmente garantir aqui era que o dicionário de origem tinha que estar vazio no final antes de prosseguir. Dentro do loop while, isso é feito passo a passo, usando popitem(). Mas também uma clear()instrução as muito primeira imediatamente após a compreensão for é boa para isso

Examine o pseudocódigo da página da Wikipedia sobre ordenação por inserção :

i ← 1
while i < length(A)
    j ← i
    while j > 0 and A[j-1] > A[j]
        swap A[j] and A[j-1]
        j ← j - 1
    end while
    i ← i + 1
end while

Por favor, explique por que isso é afirmado na literatura :

The number of exchanges used by insertion sort is equal to the number of 
inversions in the array, and the number of compares is at least equal to 
the number of inversions and at most equal to the number of inversions
plus the array size minus 1.

Uma troca de elemento adjacente (ou seja, do ' elemento selecionado atual ', com aqueles no subarray ordenado (ou seja, começando da extremidade esquerda do array original)) removeria apenas uma inversão.
Embora para uma lista dada de elementos, introduzir uma troca pode adicionar muitas inversões; digamos para a lista: 123, trocando o elemento 3com o elemento 1, que introduz 3inversões.
E o número de comparações necessárias é três:

i=1:<2,3>, i=2:<1,3>, <1,2>

Além disso, o número de inversões é três na lista:321

Esse número de inversões também é dado por nC2, onde né o tamanho da lista.

Digamos, para uma lista de tamanho ordenada reversamente 4: 4321, tenha seis inversões: <4,3>,<4,2>,<4,1>,<3,2>,<3,1>,<2,1>, que também é o número de 2-subconjuntos, de um n-conjunto. Em ambos os problemas, devido à ausência de ordenação envolvida, tenha o número de combinações a serem contadas.

As etapas (comparações+trocas) envolvidas na aplicação da ordenação por inserção à lista ordenada inversamente <4321>são:

1. i ← 1, j ← 1, A[0] > A[1]:    swap A[1] and A[0], j ← 0:     <3421>
2. i ← 2, j ← 2, A[1] > A[2]:    swap A[2] and A[1], j ← 1:     <3241>
          j ← 1, A[0] > A[1]:    swap A[1] and A[0], j ← 0:     <2341>
3. i ← 3, j ← 3, A[2] > A[3]:    swap A[3] and A[2], j ← 2:     <2314>
          j ← 2, A[1] > A[2]:    swap A[2] and A[1], j ← 1:     <2134>
          j ← 1, A[0] > A[1]:    swap A[1] and A[0], j ← 0:     <1234>

Mas, não consigo entender quando o número máximo de comparações é igual a number of inversions + array size -1; quanto ao pior caso de uma matriz de classificação reversa, de tamanho n; o número de inversões é igual a nC2.

De onde viriam as demais comparações, ou seja, 'n-1'as comparações?

A literatura mencionada acima afirma que a fonte dessas 'n-1'comparações é:

additional compare might happen for the value of `i` from `1` to `n-1` (when `a[i]` does not reach the left end of the array).

Há confusão causada pela parte, entre colchetes; como o que se quer dizer com: (when a[i] does not reach the left end of the array).
Este caso pode significar o caso de listas, onde o 'primeiro elemento' (i=0)está em sua posição final, digamos: 1423. Ou em outras palavras, fala sobre all the possiblecomparações, incluindo aquela em que há noinversão.

Digamos que, para 1423, há duas inversões, mas é preciso ter comparações extras de: <1,4>, <1,2>, <1,3>, <2,3>. Mas, essas são então quatro comparações, não três (tamanho da matriz: 4 menos 1).

Também não estou claro sobre o texto usado na literatura, pois tal comparação não é mostrada explicitamente no algoritmo.

A mesma literatura lista seu código C++ para Insertion-sort aqui , que também não mostra explicitamente nenhuma comparação desse tipo.

Tenho um dataframe Polars corpuscom uma coluna de string e milhões de linhas.
Também tenho uma lista de substrings substrings.

Posso pegar uma substring e consultar em quantas linhas essa substring aparece com:

corpus.select(pl.col('contents').str.contains(substrings[0]).sum()).item()

Isso funciona bem para uma substring, mas tenho 10.000 substrings para verificar. Qual é a maneira mais eficiente em Polars de verificar todas elas?

Considerei converter substringsem seu próprio dataframe polars e, então, executar um inner-join na presença de substring, agrupando por palavra-chave e, então, contando o tamanho dos grupos. No entanto, isso parece muito caro de uma perspectiva de sobrecarga de RAM, e estou limitado em RAM.

Existe uma maneira melhor/mais limpa?

Abordagem lenta atual:

import polars as pl

substrings = pl.DataFrame({'substring': ['a', 'b', 'c']})
corpus = pl.DataFrame({'contents': ['aBMMmcICmY', 'ORqkIJCwjV', 'JTQHufYApo', 'SNoqiJxpMY', 'SYbEsasrzt', 'XLinDPSRld', 'iInkOGqBDU', 'vBtykwGOqN', 'ZIpOdkkXBd', 'iUokuiefBS']})

def count_occurrences(substring):
    return corpus.select(pl.col('contents').str.contains(substring).sum()).item()

substrings = substrings.with_columns(pl.col('substring').map_elements(count_occurrences).alias('frequency'))

Saída:

shape: (3, 2)  
┌───────────┬───────────┐  
│ substring ┆ frequency │  
│ ---       ┆ ---       │  
│ str       ┆ i64       │  
╞═══════════╪═══════════╡  
│ a         ┆ 2         │  
│ b         ┆ 1         │  
│ c         ┆ 1         │  
└───────────┴───────────┘  

Este é meu código:

#include <iostream>
#include <vector>
using namespace std;

int BubbleSort(vector<int>, int);

int main(){

    vector<int> lista_y2 {1, 2, 0};
    cout << BubbleSort(lista_y2, lista_y2.size()) << endl;
    cout << lista_y2[0] << lista_y2[1] << lista_y2[2] << endl;
    
    
    return 0;
}


int BubbleSort(vector<int> lista_y2, int m){
    int swaps{0};
    for (int fim {m-1}; fim >= 0; fim--){
        for (int inicio {0}; inicio < fim; inicio++){
            if (lista_y2[inicio] > lista_y2[inicio+1]){
                lista_y2[inicio] = lista_y2[inicio+1] + lista_y2[inicio];
                lista_y2[inicio+1] = lista_y2[inicio] - lista_y2[inicio+1];
                lista_y2[inicio] = lista_y2[inicio] - lista_y2[inicio+1];
                swaps++;
            }
        }
    }
    return swaps;
}

Ele retorna os swaps como deveria. Mas quando tento imprimir os elementos do lista_y2, ele não mudou depois do BubbleSort. Alguém pode me ajudar a consertar isso, por favor?

Estou tentando sobrepor letras em um <p>elemento com a letra da esquerda em cima, tentei colocar cada letra em um intervalo e definir o z-index, no entanto, isso parece não funcionar, CodePen . Quero a letra da esquerda em cima da letra da direita.

Como posso sobrepor as letras da esquerda em cima à direita em baixo?

Código:

@font-face {
  font-family: 'CloudySunday';
  src: url('https://fritzfromtechsupport.com/fonts/CloudySunday.ttf') format('truetype');
}

<div>
  <p style="letter-spacing: -0.8rem;font-family: 'CloudySunday';">
    <span style="z-index: 1000;color: green;font-size: 70px;filter: drop-shadow(0px 2px black) drop-shadow(0 -2px black) drop-shadow(2px 0 black) drop-shadow(-2px 0 black);">
  h
</span>
    <span style="z-index: 100;color: red;font-size: 70px;filter: drop-shadow(0px 2px black) drop-shadow(0 -2px black) drop-shadow(2px 0 black) drop-shadow(-2px 0 black);">
  i
</span>
  </p>
</div>