All perguntas(coding)

Estou tentando formatar o título de um facet_wrapgráfico para corresponder ao estilo das faixas de facetas. No gráfico abaixo, adicionei um título "len", mas sua formatação não se parece com a das faixas de facetas (por exemplo, 0,5, 1, 2) à direita. Como posso fazer o título se parecer com as faixas de facetas (por exemplo, caixa retangular cinza, contorno preto, texto centralizado na largura do gráfico, etc.)?

library(tidyverse)

ToothGrowth |> 
  ggplot(aes(x = dose, y = len)) + 
  geom_boxplot(aes(fill = supp)) +
  labs(title = 'len',
       y = NULL) +
  theme_bw() +
  facet_wrap(~dose, ncol = 1, strip.position = "right")

^{Criado em 28/04/2025 com reprex v2.1.1}

Declaração do problema:

Você recebe uma matriz de inteiros arr de tamanho n.

Selecione uma subsequência de números inteiros e reorganize-os para formar uma sequência circular de modo que a diferença absoluta entre quaisquer dois números inteiros adjacentes (incluindo o último e o primeiro) seja no máximo 1.

Encontre o número máximo de inteiros que podem ser selecionados.

Observações:

Uma subsequência é formada pela exclusão de zero ou mais elementos sem alterar a ordem dos elementos restantes.

Os números inteiros selecionados podem ser reorganizados em qualquer ordem.

A sequência é circular — o último e o primeiro inteiros são considerados adjacentes.

Restrições:

1 <= n <= 2 × 10^5

0 <= arr[i] <= 10^9

Exemplos:

Input: arr = [4, 3, 5, 1, 2, 2, 1]
Output: 5
Explanation: maximum length subsequence is : [3, 1, 2, 2, 1], it can be rearranged to seq : [2, 1, 1, 2, 3] of length 5, note that the condition must be satisfied in circular also, means abs(seq[0] - seq[seq.length-1]) means abs(2-3) <= 0 

Input: arr = [3, 7, 5, 1, 5]
Output: 2
Explanation: maximum length subsequence is : [5,5] of length 2

Input: arr = [2, 2, 3, 2, 1, 2, 2]
Output: 7
Explanation: maximum length subsequence is : [2,2,3,2,1,2,2] of length 7

Input: arr = [1,2,3,4,5]
Output = 2
Explanation: maximum length subsequence is : [1,2] or [2,3] or [3,4] or [4,5], so length is 2. 

Observe que a subsequência também deve satisfazer a condição circular. Aqui está meu código:

import java.util.*;

class Main {
    public static int solve(int[] arr) {
        Map<Integer, Integer> freq = new HashMap<>();
        for (int num : arr) {
            freq.put(num, freq.getOrDefault(num, 0) + 1);
        }

        int max = 0;
        for (int num : freq.keySet()) {
            int count = freq.get(num);
            int countWithNext = freq.getOrDefault(num + 1, 0);
            int countWithPrev = freq.getOrDefault(num - 1, 0);
            max = Math.max(max, countWithPrev + count + countWithNext);
        }

        return max;
    }

    public static void main(String[] args) {
        System.out.println(solve(new int[]{4,3,5,1,2,2,1})); // Expected: 5
        System.out.println(solve(new int[]{3,7,5,1,5})); // Expected: 2
        System.out.println(solve(new int[]{2,2,3,2,1,2,2})); // Expected: 7
        System.out.println(solve(new int[]{1,2,3,4,5})); // Expected: 2
    }
}

Sou capaz de encontrar as subsequências de comprimento máximo, mas não consigo encontrar como atender à condição circular, então, para o caso de teste [1,2,3,4,5], meu código está retornando 5 em vez de 2.

Além disso, a abordagem em si está falhando para a entrada [1,2,3,4,3,2], conforme comentado por John Bollinger

Qual é a abordagem correta para resolver isso com menos complexidade de tempo?

Estou criando um jogo de parkour e me deparei com um problema. Há uma mecânica de corrida na parede, em que, se você estiver correndo na parede, a rotação do seu jogador fica travada no plano da parede. Isso funciona perfeitamente, desde que você acerte o lado esquerdo (oeste) da parede. Quando estiver no lado direito (leste) da parede, o jogador é virado na direção errada.

private void WallStick()
{
    if (leftWall) wallNormal = leftWallHit.normal.y;
    else if (rightWall) wallNormal = rightWallHit.normal.y;

    if (leftWall) playerMovement.rotationScript.yRotation = wallNormal + 90f;
    else if (rightWall) playerMovement.rotationScript.yRotation = wallNormal - 90f;
}

leftWall e rightWall são valores booleanos para ver em que direção a parede está para o jogador. Os acertos são raycasts. Todo o resto parece autoexplicativo, mas faça perguntas se necessário. Este código funciona perfeitamente como indicado, mas apenas se o jogador correr no lado oeste da parede.

Eu poderia dividir cada parede em 2 partes e atribuir uma layerMask para diferenciar qual lado o raio atinge, mas isso parece muito desajeitado e me faria redesenhar o mundo inteiro.

Alguma ideia?

Tenho esta função que converte um mês inglês para um mês francês:

def changeMonth(month):
    global CurrentMonth
    match month:
        case "Jan":
            return "Janvier"
        case "Feb":
            return "Février"
        case "Mar":
            return "Mars"
        case "Apr":
            return "Avril"
        case "May":
            return "Mai"
        case "Jun":
            return "Juin"
        case "Jul":
            return "Juillet"
        case "Aug":
            return "Août"
        case "Sep":
            return "Septembre"
        case "Oct":
            return "Octobre"
        case "Nov":
            return "Novembre"
        case "Dec":
            return "Décembre"

        # If an exact match is not confirmed, this last case will be used if provided
        case _:
            return ""

e eu tenho um col de pandas df["month"]= df['ic_graph']['month'].tolist():

agora o que estou procurando é passar a coluna df["mês"] pela função changeMonth para exibir o df["mês"] em meses franceses

A propósito, não quero usar o

>>> import locale
>>> locale.setlocale(locale.LC_ALL, 'fr_FR')

Aqui está meu trecho de código JavaFX:

  <stylesheet value="colours.css" />

Isso está dentro de um objeto GridPane, logo após a linha com a tag GridPane.

O IntelliJ diz que não consegue compilar o símbolo "stylesheet" e que o atributo value não é permitido. Também recebo um erro muito longo quando tento executá-lo.

Tentei pesquisar no SO e online (não sou muito bom em usar javaFX) e alterei o "valor da folha de estilo" para outras coisas algumas vezes (não lembro exatamente o que), mas nada funcionou.

Dado um dataframe polar, quero extrair todas as linhas duplicadas e também aplicar uma condição de filtro adicional, por exemplo:

import polars as pl

df = pl.DataFrame({
    "name": ["Alice", "Bob", "Alice", "David", "Eve", "Bob", "Frank"],
    "city": ["NY", "LA", "NY", "SF", "LA", "LA", "NY"],
    "age": [25, 30, 25, 35, 28, 30, 40]
})

# Trying this:
df.filter((df.is_duplicated()) & (pl.col("city") == "NY"))  # error

Entretanto, isso resulta em um erro:

SchemaError: não é possível descompactar séries de tipos objectembool

O que faz alusão que df.is_duplicated()retorna uma série do tipo object, mas na realidade, é uma BooleanSeries.

Surpreendentemente, reordenar os predicados colocando a expressão primeiro faz com que funcione ( mas por quê? ):
df.filter((pl.col("city") == "NY") & (df.is_duplicated())) # works!gera corretamente:

shape: (2, 3)
┌───────┬──────┬─────┐
│ name  ┆ city ┆ age │
│ ---   ┆ ---  ┆ --- │
│ str   ┆ str  ┆ i64 │
╞═══════╪══════╪═════╡
│ Alice ┆ NY   ┆ 25  │
│ Alice ┆ NY   ┆ 25  │
└───────┴──────┴─────┘

Entendo que a abordagem ideal ao filtrar duplicatas com base em um subconjunto de colunas é usar pl.struct, como:
df.filter((pl.struct(df.columns).is_duplicated()) & (pl.col("city") == "NY")) # works
O que funciona bem com a condição de filtro adicional.

No entanto, não estou usando intencionalmente pl.structporque meu dataframe real tem 40 colunas e quero verificar se há linhas duplicadas com base em todas as colunas, exceto três, então fiz o seguinte:
df.filter(df.drop("col1", "col2", "col3").is_duplicated()) O que funciona bem e é muito mais conveniente do que escrever todas as 37 colunas em um arquivo pl.struct. No entanto, isso falha ao adicionar uma condição de filtro adicional à direita, mas não à esquerda :

df.filter(
    (df.drop("col1", "col2", "col3").is_duplicated()) & (pl.col("col5") == "something")
    )  # breaks!

df.filter(
    (pl.col("col5") == "something") & (df.drop("col1", "col2", "col3").is_duplicated())
    )  # works!

Por que a ordem dos predicados (Série e Expressão vs. Expressão e Série) importa.filter()neste caso? Esse é um comportamento intencional em Polars ou um bug?

Como a localidade do cache afeta o desempenho do ArrayList em comparação ao LinkedList em Java?

Ouvi dizer que ArrayList tem uma vantagem em termos de localidade de cache, mas não entendo completamente o porquê. Como Java armazena objetos na memória como referências, acessar elementos em qualquer uma das listas não exigiria saltar para locais aleatórios na memória?

Vi esta publicação recente sobre o mesmo erro, e ela foi fechada porque o erro não pôde ser reproduzido. Recebi o mesmo erro ontem à noite e é facilmente reproduzível. Não sei qual a relação entre os dois, mas eis o que aconteceu comigo.

Eu estava tentando determinar a linha mais distante que é alcançável. Por exemplo, mesmo que sua planilha tenha apenas o padrão de 1000 linhas, você pode escrever =ROW(OFFSET(A1,9999,))para reach A10000. Ele retornará 10000. Depois de algumas tentativas e erros, descobri que poderia chegar ao ponto mais distante usando um OFFSET. aninhado.

=row(offset(offset(offset($A$1,B1,),C1,),D1,))

A última linha alcançável é a linha 2,147,483,647. Se eu tentasse ir para 2,147,483,649ou além, recebia um erro OFFSET, que avaliava um intervalo fora dos limites . Mas, logo antes disso, encontrei um buraco de minhoca. Isso mesmo, tentei alcançar a linha 2,147,483,648usando =row(offset(offset(offset($A$1,700000000,),700000000,),747483647,))e o que recebi foi -2,147,483,648. Você pode ver os resultados abaixo (a coluna E contém as caixas de seleção usadas para ativar/desativar as fórmulas).

Como um buraco de minhoca, ele vai para o outro lado do universo em folha. Eu poderia ir para a esquerda/direita naquela linha e até voltar para este lado, mas não consegui subir/descer nenhuma linha daquele lado. Estranho, sim, mas não prejudicial, e pretendo relatar isso.

No entanto, mais tarde, ao tentar abrir meu complemento pessoal, recebi o seguinte erro de execução. Exceção: Falha no Service Spreadsheets ao acessar o documento com ID ####. [linha: 77, função: myGlobalConfig, arquivo: core/lib/Config.

Depois de me esforçar para identificar o problema, tive a ideia maluca de verificar se o buraco de minhoca era a fonte. E era. Recebi o erro quando ativei aquela fórmula específica. O problema desapareceu quando desativei aquela fórmula.

Até criei uma função básica no script vinculado para recuperar o nome da planilha e usar o Toast para exibi-lo. Quando a fórmula do meio foi ativada, ocorreu o mesmo erro, gerando o valor da linha negativa. O erro desaparece quando a função é desativada.

Isso tem relação com a outra postagem mencionada anteriormente? Alguém sabe por que a linha está negativa?

digamos que temos um trecho de código

builder.Services.AddHttpClient("typicode", c =>
    {
        c.BaseAddress = new Uri("https://xxx");
        c.DefaultRequestHeaders.Add(
            "accept", "application/json");
    })
    .ConfigurePrimaryHttpMessageHandler(() => new SocketsHttpHandler()
    {
        PooledConnectionLifetime = TimeSpan.FromMinutes(5),
    })
    .SetHandlerLifetime(TimeSpan.FromMinutes(10));

Não entendi bem por que ele precisa chamar SetHandlerLifetime(TimeSpan.FromMinutes(10)ou quais são os benefícios de chamá-lo. Sei que SetHandlerLifetimecontrola por quanto tempo uma SocketsHttpHandlerinstância (e seu pool de conexões) é reutilizada no "nível do manipulador" e PooledConnectionLifetime = TimeSpan.FromMinutes(5)é para o "nível da conexão".

mas não é PooledConnectionLifetime = TimeSpan.FromMinutes(5)suficiente usar isso, imagine que eu uso esse HttpClient para fazer várias solicitações para URLs diferentes, como foo1.com, foo2.com...foo10.com. Eu gostaria de um PooledConnectionIdleTimeout de 5 minutos no nível de conexão, então, por exemplo, a conexão para foo1.com expira após 5 minutos, mas foo2.com ainda está ativo e eu quero reutilizá-lo mais tarde, mas SetHandlerLifetime limpará todos os pools após 10 minutos?

É possível usar o OpenCV para salvar um TIFF usando compactação CCITT (Grupo 4)?

Parece haver uma limitação (ou código ausente) que permite que essas imagens de 1 bpp sejam salvas.