All perguntas(coding)

Como um elemento pode ser definido para se comportar como um elemento fixo somente quando a altura restante do elemento for maior que um tamanho específico (que chamarei de margem do contêiner fixo)?

Por exemplo, na imagem abaixo:

Você pode ver que o contêiner azul claro tem um elemento vermelho pegajoso, e a margem do contêiner pegajoso é mostrada como uma linha azul escura. Quando o elemento do contêiner está saindo da tela, o elemento vermelho permanece pegajoso até que a margem do contêiner pegajoso atinja o fim do contêiner.

Aqui está um código inicial para testar algumas soluções. Tentei fazer da linha azul um contêiner, mas isso bagunça a posição inicial do resto do conteúdo.

section {
  height: 300lvh;
}

.content {
  background: #eee;
  height: 80lvh;
}

.box {
  height: 120lvh;
  background: #9f9;
  display: flex;
  flex-direction: column;
}

.sticky {
  position: sticky;
  top: 0px;
  height: 20lvh;
  background: #99f;
}

.end {
  color: red;
  padding-top: 50px;
}

.flex-end {
  flex-grow: 1;
  display: flex;
  flex-direction: column;
  justify-content: flex-end;
}

<section>
  <div class="content">Prev content</div>
  <div class="box">
    <div class="sticky">
      Sticky element
    </div>
    <div>
      Content
    </div>
    <div class="flex-end">
      Content
    </div>
  </div>
  <div class="content end">
    When this is visible, the sticky element should go up
  </div>
</section>

Estou procurando uma função capaz de receber uma m x nmatriz que repita cada linha n vezes em uma grade de identidade de tamanho m.

Para demonstração:

input = [[a1, b1, c1],
         [a2, b2, c2]]

output = [[a1, b1, c1,  0,  0,  0],
          [a1, b1, c1,  0,  0,  0],
          [a1, b1, c1,  0,  0,  0],
          [ 0,  0,  0, a2, b2, c2],
          [ 0,  0,  0, a2, b2, c2],
          [ 0,  0,  0, a2, b2, c2]]

Da última vez que perguntei algo semelhante, me falaram do produto Kronecker: existe alguma função semelhante?

sealed interface I permits A, B, C { }
final class A implements I { }
final class B implements I { }
record C(int j) implements I { } // Implicitly final
record Box(I i) { }
int testExhaustiveRecordPatterns(Box b) {
    return switch (b) { // Exhaustive!
        case Box(A a) -> 0;
        case Box(B b) -> 1;
        case Box(C c) -> 2;
    };
}

Este é um exemplo que aparece na especificação da linguagem Java 22 (14.11.1.1) .

Posteriormente, a especificação fornece algumas explicações:

Determinar se esse bloco de switch é exaustivo requer a análise da combinação dos padrões de registro. O conjunto que contém o padrão de registro Box(I i)cobre o tipo Box, e assim o conjunto que contém os padrões Box(A a), Box(B b), e Box(C c)pode ser reescrito para o conjunto que contém o padrão Box(I i). Isso ocorre porque o conjunto que contém os padrões A a, B b, C creduz-se ao padrão I i(porque o mesmo conjunto cobre o tipo I), e assim o conjunto que contém os padrões Box(A a), Box(B b), Box(C c)reduz-se ao padrão Box(I i).

No entanto, ainda não é detalhado o suficiente para mim. Posso ver que essas regras devem ser citadas ao determinar se o bloco switch é exaustivo (Algumas regras relevantes):

O bloco switch de uma expressão switch ou instrução switch é exaustivo para uma expressão seletora ese um dos seguintes casos se aplicar:

• O conjunto que contém todas as constantes de caso e padrões de caso que aparecem em um rótulo de caso desprotegido (conhecidos coletivamente como elementos de caso ) associado ao bloco switch não é vazio e cobre o tipo da expressão do seletor e.

Um conjunto de elementos de caso, P, cobre um tipo Tse um dos seguintes casos se aplicar:

• O tipo Tnomeia uma classe selada abstrata ou interface selada Ce para cada subclasse ou subinterface direta permitida Dde C, uma das duas condições a seguir é válida:

1. Não existe um tipo que nomeie De seja um subtipo de T, ou
2. Existe um tipo Uque nomeia De é um subtipo de T, e Pabrange U.

• P reescreve para um conjunto Qe Qcobre T.

Um conjunto de elementos de caso, P, é reescrito no conjunto Q, se um subconjunto de Pfor reduzido a um >padrão p, e Qconsiste nos elementos restantes de Pjunto com o padrão p.

Um conjunto não vazio de padrões, RP, reduz-se a um único padrão rpse uma das seguintes condições for válida:

– RPabrange algum tipo Ue rpé um padrão de tipo do tipo U.

– RPconsiste em padrões de registro cujos tipos apagam todos para a mesma classe de registro Rcom k(k≥1) componentes e há um componente distinto cr(1≤r≤k) de Rtal forma que para cada outro componente ci (1≤i≤k, i≠r) o conjunto contendo os padrões de componentes dos padrões de registro correspondentes ao componente cié equivalente a um único padrãoqi , o conjunto contendo os padrões de componentes dos padrões de registro correspondentes ao componente crreduz-se a um único padrãoq e rpé o padrão de registro do tipo Rcom uma lista de padrões consistindo nos padrões q1, ..., qr-1, q, qr+1, ..., qk.

Um conjunto não vazio de padrões EP é equivalente a um único padrão ep se uma das seguintes condições for válida: › EPconsiste em padrões de tipo cujos tipos têm todos a mesma eliminação T, e epé um padrão de tipo do tipo T. › EPconsiste em padrões de registro cujos tipos apagam todos para a mesma classe de registro Rcom k(k≥1) componentes e para cada componente de registro o conjunto contendo os padrões de componentes correspondentes dos padrões de registro é equivalente a um único padrão qj(1≤j≤k), e epé o padrão de registro do tipo Rcom uma lista de padrões de componentes consistindo nos padrões de componentes q1,...qk.

No entanto, tenho alguma dificuldade em entender essas regras, especialmente as partes em negrito. Por exemplo,O que significa " from the record patterns matching to component ci "," from the record patterns matching to the component cr "?Para ser mais preciso, acho que não entendi bem o significado de " matching to " aqui. De acordo com as explicações na especificação, acho que a frase "This is because the set containing the patterns A a, B b, C creduces to the pattern I i" deve ter usado as regras na parte em negrito.No entanto, não consigo descobrir como A a, B b, C csurgiu.

Você poderia me ajudar a analisar os regulamentos na especificação em combinação com os exemplos?Sei que não é uma tarefa fácil. Obrigado por ler e responder.

Tentei salvar uma planilha específica de um XLSX como CSV. Primeiro, tentei usar setActiveSheetIndexByName()a função para definir a planilha ativa e chamar o método writer de \PhpOffice\PhpSpreadsheet\Writer\Csv, mas sem sorte. De alguma forma, o writer salvou a primeira planilha. Tentei indexar por nome, por número, mas não foi uma pequena diferença.

Agora, há um código que estou experimentando:

$reader = \PhpOffice\PhpSpreadsheet\IOFactory::createReader("Xlsx");
$reader->setReadDataOnly(true);

$spreadsheet = $reader->load('infile.xlsx');
foreach($spreadsheet->getAllSheets() as $sheet)
{
   $spreadsheet->setActiveSheetIndexByName($sheet->getTitle());
   $activeSheet = $spreadsheet->getActiveSheet();
   $title = $activeSheetgetTitle();
   echo $title . PHP_EOL;
   $writer = new \PhpOffice\PhpSpreadsheet\Writer\Csv($spreadsheet);
   $writer->save($title . '.csv', 2);
}

A saída do console é como eu esperava: a lista de nomes de planilhas. A saída do sistema de arquivos é quase como eu esperava: muitos arquivos CSV com nomes próprios. No entanto, o conteúdo é o mesmo. Quero dizer, pouco a pouco, o mesmo conteúdo da primeira planilha. Não importa se eu altero a planilha ativa.

Minha pergunta é: como posso salvar um arquivo CSV com base em uma planilha específica?

ATUALIZAÇÃO: Se eu reordenar as planilhas na pasta de trabalho, obtenho o CSV que preciso. Mas isso é apenas um hack instantâneo e não funcionará quando eu precisar trabalhar com mais planilhas.

Quero traçar a participação de três variáveis ​​de cada ponto geográfico.

Achei que isso seria fácil de fazer com valores RGB e consegui fazer simplesmente assim:

data <- data.frame(
  Variable = c("Point1", "Point2", "Point3"),
  R = c(0.4, 0.6, 0.3),
  G = c(0.3, 0.2, 0.4),
  B = c(0.3, 0.2, 0.3),
  x = c(1, 2, 4),
  y = c(5, 6, 7)
)
color_plot <- rgb(data$R, data$G, data$B)

ggplot() +
  geom_point(data = data, aes(x = x, y = y, color = color_plot))  

O problema é que os valores de cor são discretos, tornando a legenda que o ggplot produz inútil. Existe uma maneira elegante de adicionar uma escala de cor significativa (contínua) a este gráfico? Idealmente, os nomes de R, G e B estariam na escala.

Declarei uma classe de template que recebe um size_targumento de template. Aqui está a classe (ou struct neste caso):

typedef unsigned char byte;

template <size_t NumBytes>
struct Field
{
    bool is_set = false;
    std::array<byte, NumBytes> data;

    Field() = default;
    Field(byte &&val, bool is_set = false);
    Field(std::initializer_list<byte> predef);
};

A ideia é usá-lo para campos de cabeçalho de arquivo (ELF neste caso). Quero poder definir um campo da seguinte maneira:

const Field EI_MAG = {0x7F, 0x45, 0x4c, 0x46};

E fazer com que ele deduza automaticamente o argumento de modelo NumBytes, tal que, neste caso, EI_MAGseria do tipo const Field<4>. O compilador reclama muito (claro) e eu eventualmente chego ao ponto de definir um guia de dedução de modelo. Minha melhor (e mais recente) tentativa é a seguinte:

template <class Type, class... Data>
Field(Type, Data...) -> Field<sizeof...(Data)>;

Mas o compilador ainda reclama com o seguinte erro:

error: invalid use of template-name ‘Field’ without an argument list
   53 |     const Field EI_MAG          = {0x7F, 0x45, 0x4c, 0x46};
      |           ^~~~~

Então como devo fazer isso? É possível? Se não, como std::array faz isso? Estou batendo a cabeça há várias horas e ainda tenho um pouco de dificuldade com a forma como a dedução de modelo e os guias de dedução de modelo funcionam. Qualquer ajuda seria muito apreciada.

OBSERVAÇÃO: Todo o código apresentado está localizado em um .hpparquivo e todas as definições de função struct estão localizadas no .cpparquivo correspondente, que não é apresentado aqui.

Tenho uma coleção mongo que armazena dados de cidade/país em vários idiomas. Por exemplo, a seguinte consulta:

db.cities_database.find({ "name.pl.country": "Węgry" }).pretty().limit(10);

Retorna dados no seguinte formato:

[
  {
    _id: ObjectId('67331d2a9566994a18c505aa'),
    geoname_id_city: 714073,
    latitude: 46.91667,
    longitude: 21.26667,
    geohash: 'u2r4guvvmm4m',
    country_code: 'HU',
    population: 7494,
    estimated_radius: 400,
    feature_code: 'PPL',
    name: {
      pl: { city: 'Veszto', admin1: null, country: 'Węgry' },
      ascii: { city: 'veszto', admin1: null, country: null },
      lt: { city: 'Veszto', admin1: null, country: 'Vengrija' },
      ru: { city: 'Veszto', admin1: null, country: 'Венгрия' },
      hu: { city: 'Veszto', admin1: null, country: 'Magyarország' },
      en: { city: 'Veszto', admin1: null, country: 'Hungary' },
      fr: { city: 'Veszto', admin1: null, country: 'Hongrie' }
    }
  }
...
]

Quero poder usar a mesma consulta usando apenas caracteres em inglês, então, neste exemplo, gostaria de consultar por "name.pl.country": "Wegry"(em vez de caractere, ęgostaria que o Mongo o tratasse eao executar esta consulta).

É possível conseguir isso?

Até agora tentei usar a ordenação assim:

db.cities_database.find({ "name.pl.country": "Wegry" }).collation({ locale: "pl", strength: 1 }).pretty().limit(10);

mas essa consulta não retorna nada.

Estou tentando adicionar um marcador de vídeo do YouTube em algum lugar.

Se o URL do meu vídeo do YouTube for: 'https://www.youtube.com/watch?v=xxxxxx&t=12:13'
, ele deverá ser convertido no formato: 'https://www.youtube.com/watch?v=xxxxxx&t=25s'

Basicamente eu mudo o formato do timer: 12:13para 733s(12*60 + 13)

Eu posso fazer isso de forma simples.
Mas eu quero fazer isso em uma única linha com validação regex como:

let url = 'https://www.youtube.com/watch?v=xxxxxx&t=12:13';

console.log(url.replace(/(\d+)\:(\d+)/g, '$1$2'));

let cUrl = url.replace(/(\d+)\:(\d+)/g, `${Number($1)*60 + Number($2)}s`);
console.log(cUrl);

Saída do console do navegador:

Alguém pode me orientar por que está mostrando o NaN?
O que estou fazendo errado?

Gostaria de levar o produto dentro de um grupo em polares

O seguinte funciona, mas suspeito que haja uma maneira mais elegante/eficiente de executar esta operação. Obrigado

import polars as pl
import numpy as np

D = pl.DataFrame({'g':['a','a','b','b'],'v':[1,2,3,4],'v2':[2,3,4,5]})
D.group_by('g').agg(pl.all().map_elements(
                        lambda group: np.prod(group.to_numpy()),return_dtype=pl.Float64))

Estou enfrentando um problema raro em que SetThreadpoolTimerEx não invoca a função de retorno de chamada conforme esperado.

Ambiente:

Sistema operacional: Windows 10 22H2 (Build 19045.5131)

Visual Studio: 2022 (Versão 17.12.0)

SDK e conjunto de ferramentas: Windows SDK 10.0.19041.0, conjunto de ferramentas de plataforma v143

Emitir:

De acordo com a documentação do SetThreadpoolTimerEx ( link ):

Se o estado anterior do temporizador foi "definido" e a função retornar FALSE, então um retorno de chamada está em andamento ou prestes a começar.

No entanto, no meu caso, a função retorna FALSE, mas o callback não está sendo chamado. Isso faz com que meu programa trave enquanto espera o callback sinalizar a conclusão.

Código C++ para reproduzir:

#include <iostream>
#include <atomic>
#include <chrono>
#include <Windows.h>

std::atomic<bool> callbackDone = false;

VOID(NTAPI callback)(
    _Inout_     PTP_CALLBACK_INSTANCE Instance,
    _Inout_opt_ PVOID                 Context,
    _Inout_     PTP_TIMER             Timer
    )
{
    printf("callback...\n");
    callbackDone = true;
}

int main() {
    bool canFail = false;

    while (true) {
        callbackDone = false;
        auto timer = CreateThreadpoolTimer(callback, nullptr, nullptr);

        LARGE_INTEGER relativeTime = {};

        relativeTime.QuadPart = 10000000 * -1;

        FILETIME relativeTimeFt = {};

        relativeTimeFt.dwLowDateTime = relativeTime.LowPart;
        relativeTimeFt.dwHighDateTime = static_cast<DWORD>(relativeTime.HighPart);

        auto setRes1 = SetThreadpoolTimerEx(timer, &relativeTimeFt, 0, 0);

        Sleep(999);

        auto setRes2 = SetThreadpoolTimerEx(timer, nullptr, 0, 0);

        if (setRes2 == TRUE) {
            FILETIME now = {};
            SetThreadpoolTimerEx(timer, &now, 0, 0);
        }
        else {
            if (!callbackDone) {
                WaitForThreadpoolTimerCallbacks(timer, FALSE);
                canFail = true;
            }
        }

        if (canFail) {
            printf("waiting for possibly failed timer\n");
        }

        auto startWaitTime = std::chrono::high_resolution_clock::now();
        auto waitMsgStep = std::chrono::seconds(10);
        auto nextMsgTime = waitMsgStep;
        while (!callbackDone) {
            SleepEx(10, TRUE);

            auto waitDuration = std::chrono::duration_cast<std::chrono::seconds>(
                std::chrono::high_resolution_clock::now() - startWaitTime
            );

            if (waitDuration > nextMsgTime) {
                printf("waiting for callback to finish for %d seconds...\n", static_cast<DWORD>(nextMsgTime.count()));
                nextMsgTime += waitMsgStep;
            }
        }

        if (canFail) {
            canFail = false;
            printf("timer is ok\n");
        }

        CloseThreadpoolTimer(timer);
    }
}

Saída possível:

Problema:

Apesar de SetThreadpoolTimerEx retornar FALSE — o que, de acordo com a documentação, indica que o retorno de chamada está em andamento ou prestes a começar — a função de retorno de chamada não está sendo chamada em alguns casos raros. Isso faz com que o programa fique travado indefinidamente no loop esperando que callbackDone se torne verdadeiro.

Questões:

1. Existe algum problema conhecido com SetThreadpoolTimerEx em que o retorno de chamada pode não ser invocado mesmo que a função retorne FALSE?

2. Estou usando incorretamente as APIs do temporizador do pool de threads de uma forma que pode causar esse comportamento?

3. Como posso modificar meu código para garantir que o retorno de chamada seja sempre invocado ou para tratar corretamente o caso quando isso não for feito?

Além disso, do blog de Raymond Chen :

A última linha é a interessante: quando você cancela o timer ou o objeto wait, o thread pool tenta recuperar quaisquer retornos de chamada pendentes, mas às vezes um retorno de chamada já foi longe demais e não pôde ser recuperado. Por exemplo, o retorno de chamada pode já estar em andamento. Nesse caso, a função Set...Ex retorna FALSE para informar que você ainda não terminou. Você tem que esperar o retorno de chamada ser concluído antes que tudo esteja finalmente pronto.

No meu caso, SetThreadpoolTimerEx retorna FALSE, e espero 10 segundos ou mais, mas o retorno de chamada nunca é invocado.