All perguntas(coding)

Quero agrupar a legenda em ggplotvárias partes. Vejamos o exemplo abaixo (retirado de https://stackoverflow.com/a/68608592/15910619 como resposta aceita de @stefan).

library(ggplot2)
library(ggnewscale)

diamonds$cut = factor(diamonds$cut, levels=c("Fair","Good", "Very Good",
                                             "Premium","Ideal"))

labels <- levels(diamonds$cut)
labels <- setNames(labels, labels)
labels["Fair"] <- "Very Good"
labels["Good"] <- "Premium"

colors <- hcl(seq(15, 325, length.out = 5), 100, 65)
colors <- setNames(colors, levels(diamonds$cut))

ggplot() + 
  geom_bar(data = diamonds, aes(color, fill = cut)) + 
  scale_fill_manual(aesthetics = "fill", values = colors, labels = labels[1:2],
                    breaks = names(colors)[1:2], name = "First Group:",
                    guide = guide_legend(title.position = "left", order = 1)) +
  new_scale_fill() +
  geom_bar(data = diamonds, aes(color, fill = cut)) + 
  scale_fill_manual(aesthetics = "fill", values = colors, labels = labels[3:5],
                    breaks = names(colors)[3:5], name = "Second Group:",
                    guide = guide_legend(title.position = "left", order = 0)) +
  theme(legend.position = "bottom", 
        legend.direction = "horizontal",
        legend.key = element_rect(fill = "white"))

No entanto, gostaria de alterar o estilo de posição de vários elementos da legenda, conforme demonstrado no instantâneo modificado abaixo

Existe alguma maneira de conseguir esse tipo de agrupamento na lenda ggplot?

Muito obrigado pelo seu tempo e atenção.

Tenho um arquivo de patch DTS que adiciona uma EEPROM à árvore de dispositivos. Tenho uma .bbappendreceita com estas linhas simples

PATCHTOOL = "git"
SRC_URI += " \
  file://0001-imx6dl-custom.dts.patch \
"

Iniciei o bitbake, o patch foi aplicado e a imagem foi gerada.

Ajustei algumas outras coisas. Quando reiniciei o Bitbake, recebi um erro na do_patchetapa 1, dizendo o seguinte:

NOTE: Executing Tasks
NOTE: Setscene tasks completed
ERROR: linux-custom-5.4-r0 do_patch: Applying '0001-imx6dl-custom.dts.patch' failed:
checking file arch/arm/boot/dts/imx6dl-custom.dts
Reversed (or previously applied) patch detected!  Assume -R? [n] 
Apply anyway? [n] 
Skipping patch.
1 out of 1 hunk ignored
ERROR: Logfile of failure stored in: /home/user/yocto/build/tmp/work/custom_imx6dl_r027-poky-linux-gnueabi/linux-custom/5.4-r0/temp/log.do_patch.19802
ERROR: Task (/home/user/yocto/sources/meta-custom/recipes-kernel/linux-mod/linux-custom_5.4.bb:do_patch) failed with exit code '1'

O arquivo dts em work-shared tem o patch aplicado. Se eu fizer um git logcommit na pasta work-shared, vejo o último commit do código-fonte do meu kernel (onde o dts NÃO foi corrigido) e um commit extra que oe.pathc@oeaplica o patch. Então, parece que está tudo bem. Mesmo assim, recebo este erro.

Qual pode ser a causa disso?

Fiz alguns testes extras. Removi o patch e o .bbappend que o aplica da minha receita do kernel. Estranhamente, parece que o bitbake ainda está tentando aplicar o patch. Quando executo o bitbake, recebo...

Loaded 4146 entries from dependency cache.
WARNING: /home/user/yocto/sources/meta-custom/recipes-kernel/linux/linux-custom_5.4.bb: Unable to get checksum for linux-custom SRC_URI entry 0001-imx6dl-custom.dts.patch: file could not be found

0001-imx6dl-custom.dts.patchfoi de fato excluído, mas o .bbappendarquivo também. Por que ele ainda está procurando por ele? Tentei vários comandos de limpeza ( bitbake -c clean linux-custom, bitbake -fc cleanall linux-custom), mas o bitbake continua procurando pelo patch. E ainda recebo o erro "patch aplicado anteriormente"!

Existe algum histórico que não será excluído do meu fluxo de trabalho do Yocto? O que estou perdendo?

Estou tentando atribuir uma identidade gerenciada atribuída pelo usuário ao WebApp usando a CLI do Azure. O comando segue a sintaxe abaixo:

#This command fetches the resource id of my existing managed identity with name 'myIdentity'
identityResourceId=$(az identity show --name 'myIdentity' \
  --resource-group 'myResourceGroup' --query id -o tsv)

Quando tento imprimir o valor da variável $identityResourceId, ele mostra a seguinte saída

echo "ResourceId: $identityResourceId"

ResourceId: /subscriptions/mySubscriptionId/resourceGroups/myResourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myIdentity

Assim que tento usar essa variável no comando abaixo, ele lança Code:LinkedInvalidPropertyId

az webapp identity assign --resource-group myResourceGroup --name myWebApp --identities $identityResourceId

Mensagem de erro:

(LinkedInvalidPropertyId) Property id 'C:/Program Files/Git/subscriptions/mySubscription/resourceGroups/myResourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myIdentity' at path '' is invalid. Expect fully qualified resource Id that start with '/subscriptions/{subscriptionId}' or '/providers/{resourceProviderNamespace}/'.
Code: LinkedInvalidPropertyId
Message: Property id 'C:/Program Files/Git/subscriptions/mySubscription/resourceGroups/myResourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myIdentity' at path '' is invalid. Expect fully qualified resource Id that start with '/subscriptions/{subscriptionId}' or '/providers/{resourceProviderNamespace}/'.

Não tenho certeza do porquê o ID do recurso está sendo prefixado com C:/Arquivos de Programas/Git/

Estou seguindo a referência da Microsoft:

Parâmetros em condições

e este é meu arquivo yml:

parameters:
  - name: poolType # pool type for the agent, valid values are "windows" or "linux"
    type: string
    default: "windows"

steps:
  # Echo the poolType parameterAzure
  - script: |
      echo "Pool Type: ${{ parameters.poolType }}"
    displayName: "Echo poolType"
  # set gittoken for authentications
  - ${{ if eq(parameters.poolType, 'linux') }}:
      - script: |
          git config --global --list
          git config --global url."https://token:[email protected]".insteadOf "https://[email protected]"
          git config --global --list
        displayName: 'set extra header for Git in Linux'
        env:
          MODUL_TOKEN: $(modules_token)
  - ${{ if eq(parameters.poolType, 'windows') }}:
      - script: |
          git config --global --list
          git config --global url."https://token:%MODUL_TOKEN%@dev.azure.com".insteadOf "https://[email protected]"
          git config --global --list
        displayName: 'set extra header for Git in Windows'
        env:
          MODUL_TOKEN: $(modules_token)

E esta é a saída da tarefa echo:

Por que a tarefa "'definir cabeçalho extra para Git no Linux'" não está sendo executada? A condição é verdadeira!

Primeira tentativa:

Usei o seguinte código, mas não está funcionando novamente

- script: |
      git config --global --list
      git config --global url."https://token:[email protected]".insteadOf "https://[email protected]"
      git config --global --list
    displayName: 'set extra header for Git in Linux'
    env:
      MODUL_TOKEN: $(modules_token)
    condition: ${{ eq(parameters.poolType, 'linux') }}
  - script: |
      git config --global --list
      git config --global url."https://token:%MODUL_TOKEN%@dev.azure.com".insteadOf "https://[email protected]"
      git config --global --list
    displayName: 'set extra header for Git in Windows'
    env:
      MODUL_TOKEN: $(modules_token)
    condition: ${{ eq(parameters.poolType, 'windows') }}

Estou enfrentando um problema em que o Visual Studio (2022 e 2019) leva até 10 minutos para carregar um projeto completamente. Desde clicar no atalho para iniciar o Visual Studio até selecionar e carregar um projeto completamente, os eventos de reconstrução também estão muito lentos.

Esse comportamento só acontece quando estou conectado à VPN e o SiPolicy.p7b está em vigor.

• Sem SiPolicy.p7b e conectado à VPN não há problema
• Com SiPolicy.p7b, mas não conectado à VPN, também não há problema

Alguma ideia do que pode estar causando esse comportamento estranho?

O método Cognito AdminUpdateDeviceStatusretorna ResourceNotFoundException: Device does not existmesmo que o dispositivo exista. Eu o vejo no console da AWS Device tracking loge ele foi confirmado com sucesso seguindo ConfirmDeviceos passos anteriores.

Também estou usando a região e o aplicativo cliente corretos.

Seguindo este guia de melhores práticas, tenho um módulo no meu código Fortran que define um tipo de precisão dupla,

module kind_parameters
    implicit none
    public
 
    ! Double precision real numbers, 15 digits, range 10^-307 to 10^307-1; 64 bits
    integer, parameter :: dp = selected_real_kind(15, 307)
 
 end module kind_parameters

Meu código, que usa esse tipo de precisão dupla para todas as operações de ponto flutuante, faz uso regular de MKL. Aqui, sempre uso a versão de precisão dupla das sub-rotinas MKL, ou seja, DGEMM e DSYEVD.

Não está claro para mim se meu tipo definido pelo usuário é consistente com o tipo de precisão dupla esperado pelo MKL. Em todos os meus testes até agora (com ifort/ifx), isso parece ter funcionado bem, mas existem armadilhas potenciais com minha maneira de fazer as coisas? Existe uma maneira melhor?

Estou usando o Spring Kafka 3.0.5 com o KafkaTransactionManager e o DefaultErrorHandler.

Na minha configuração de consumidor:

O modo de confirmação está definido como LOTE

O tipo de ouvinte é @KafkaListener (baseado em registro)

As transações estão habilitadas (KafkaTransactionManager)

A nova tentativa é configurada com DefaultErrorHandler.setRetryListeners(...) e 10 novas tentativas

Ao testar com um lote de mensagens, observei o seguinte:

Se o último registro em um lote pesquisado falhar, toda a transação será revertida e o deslocamento não será confirmado — como esperado.

Se o último registro for bem-sucedido, mesmo que os registros anteriores no lote tenham falhado, mas tentado novamente com sucesso, a transação inteira será confirmada e o atraso do consumidor se tornará 0.

Isso significa que o resultado final do último registro no lote parece determinar se a transação foi confirmada ou não.

Questões:

Esse comportamento é esperado — que o resultado do último registro decida a confirmação da transação?

Isso está documentado em algum lugar no Spring Kafka ou no próprio comportamento transacional do Kafka?

Existe uma maneira de tornar a confirmação da transação mais explícita por registro ou dissociá-la do status final do registro?

Qualquer esclarecimento ou links de documentação seriam muito apreciados.

Estou tentando resolver o seguinte problema algorítmico:

Todos os dias, Bob vai trabalhar e realiza uma das 26 tarefas possíveis. As tarefas são codificadas com as letras do alfabeto inglês de A a Z. Às vezes, Bob realiza tarefas atribuídas por seu chefe e, às vezes, pode escolher qual das 26 tarefas possíveis realizará ele mesmo. Esses dias são marcados com o símbolo !. O chefe definiu o plano de trabalho de Bob para os próximos N dias. Bob realmente não gosta de realizar a mesma tarefa por vários dias seguidos e, para mostrar ao chefe como está entediado, decidiu contar o número de maneiras de escolher um segmento contínuo de pelo menos dois dias durante o qual realizará a mesma tarefa todos os dias.

Ou seja, Bob considera todos os segmentos possíveis do dia L ao dia R, onde L < R, e se ele puder escolher seu trabalho de forma que as tarefas em todos os dias desse segmento sejam as mesmas, então ele considera esse segmento chato.

Ajude Bob a determinar o número de segmentos chatos no plano de trabalho para os próximos N dias enquanto ele estiver entediado.

Formato de entrada

É inserida uma única linha, que é uma sequência de caracteres composta por letras maiúsculas do inglês e o símbolo ! — o plano de trabalho para os próximos N (1 ≤ N ≤ 1000000) dias.

Formato de saída

Produza um único número — o número de segmentos de perfuração no plano.

Exemplo 1

Entrada:a!b!c

Saída: 5

Exemplo 2

Entrada:a!

Saída: 1

Notas

Todos os segmentos possíveis no primeiro exemplo estão entre |e|

|a!|b!c
a|!b|!c
a|!b!|c
a!|b!|c
a!b|!c|

Formalizei a tarefa da seguinte forma:

Problema

Dado um plano de trabalho para N dias como uma sequência composta por letras maiúsculas (de 'a' a 'z') e pontos de exclamação ('!'), conte o número de segmentos contínuos de pelo menos dois dias (ou seja, do dia L ao dia R, onde 1 ≤ L < R ≤ N) de forma que seja possível para Bob realizar a mesma tarefa em todos os dias dentro do segmento. Um segmento é considerado "chato" se:

• Todos os caracteres dentro do segmento são o mesmo caractere não-'!'.

• O segmento contém pelo menos um ponto de exclamação ('!').

Entrada

Uma única sequência representando o plano de trabalho para N dias.

A sequência consistirá apenas de letras maiúsculas em inglês (de 'a' a 'z') e pontos de exclamação ('!').

O comprimento da string N estará entre 1 e 1.000.000, inclusive (1≤N≤10 ⁶ ).

Saída

Um único inteiro representando o número total de segmentos "chatos" no plano de trabalho fornecido.

Meu Código

func solve() {
  guard let plan = readLine() else { return }
  let n = plan.count
  let planArray = Array(plan)
  var boringSegmentCount = 0
  for i in 0..<n {
    var nonWildcards = Set<Character>()
    for j in i..<n {
      if planArray[j] != "!" {
        nonWildcards.insert(planArray[j])
      }
      if j > i && nonWildcards.count <= 1 {
        boringSegmentCount += 1
      }
    }
  }
  print(boringSegmentCount)
  
}

O código Swift fornecido tem como objetivo resolver o problema iterando por todos os segmentos contínuos possíveis da string de entrada plan.

Ele usa loops aninhados para iterar por todos os segmentos contínuos possíveis da string:

• O loop externo ( i) determina o índice inicial do segmento.
• O loop interno ( j) determina o índice final do segmento.

Para cada segmento (do índice iaté j):

• Ele cria uma Setchamada nonWildcardspara armazenar caracteres únicos que não são '!'.
• Ele itera pelos caracteres dentro do segmento atual.
• Se um caractere não for '!', ele o adiciona ao nonWildcardsconjunto.
• Ele verifica se o comprimento do segmento é maior que 1 ( j > i) e se o número de caracteres não curinga exclusivos no segmento é no máximo 1 ( nonWildcards.count <= 1).
• Se ambas as condições forem verdadeiras, ele incrementa o boringSegmentCount.

O principal problema com esse algoritmo é sua complexidade de tempo quadrática, O(n²), portanto, para valores grandes de n(até 1.000.000, conforme declarado no problema), esse algoritmo pode ser muito lento e levar a um erro de limite de tempo excedido.

Minha pergunta

É possível propor um algoritmo com assintóticas mais baixas para esta tarefa? Suponho que seja possível resolver este problema em tempo linear, mas, para minha vergonha, ainda não consegui encontrar uma lógica adequada.

No meu caso específico, enfrentei um problema no SwiftUI que não permite adicionar mais de um alerta ao mesmo arquivo View. Esse problema é conhecido e já foi resolvido, por exemplo, adicionando visualizações vazias adicionais:

https://stackoverflow.com/a/67395026/805701

Mas há outro problema: o SwiftUI não reage a essa situação (os alertas simplesmente pulam). Portanto, você precisa pesquisar manualmente em todo o código para encontrar essas duplicatas, que podem ocorrer em arquivos diferentes.

É possível de alguma forma indicar onde essas duplicatas ocorrem, por exemplo, adicionando um wrapper sobre o .alert(...)modificador padrão que é gerado fatalErrorquando esse modificador já foi adicionado a uma visualização?