All perguntas(coding)

De ?options, a descrição do warnreferido

Se foram sinalizados 10 ou menos avisos, eles serão impressos, caso contrário será exibida uma mensagem informando quantos foram sinalizados.

Portanto, se houver mais de 10 avisos, eles serão compactados em uma mensagem. Por exemplo:

f <- function() {
  warning("warn 1")
  warning("warn 2")
  warning("warn 3")
  warning("warn 4")
  warning("warn 5")
  warning("warn 6")
  warning("warn 7")
  warning("warn 8")
  warning("warn 9")
  warning("warn 10")
  warning("warn 11")
  return(1)
}

f()

[1] 1
Houve 11 avisos (use warnings() para vê-los)

Como posso reduzir o limite de 10 para 1? Ou seja, mesmo que eu tenha apenas um aviso, espero que ele apareça

Houve 1 aviso (use warnings() para vê-los)

Tomemos std::sortcomo std::ranges::sortexemplo, a classe do iterador std::ranges::sorté restrita ao conceito std::random_access_iterator:

template< std::random_access_iterator I, std::sentinel_for<I> S,
          class Comp = ranges::less, class Proj = std::identity >
requires std::sortable<I, Comp, Proj>
constexpr I
    sort( I first, S last, Comp comp = {}, Proj proj = {} );

Mas std::sortnão é:

template< class RandomIt >
void sort( RandomIt first, RandomIt last );

std::sortPor que (e todos os algoritmos sem intervalo) não é restrito?

Uma questão relacionada: Qual é a diferença entre std::fill_n e std::ranges::fill_n?

Estou vendo algum comportamento inesperado ao usar o std::variant::operator<. Na situação em que o tipo possui um operador de conversão bool implícito e seu operador less não é uma função membro (em C++20 com compilador mscv 19.38).

#include <variant>

struct Foo {
    int x;
    int y;

#ifndef DROP_CAST_OP
    constexpr operator bool() const { return x || y; }
#endif

#ifdef USE_SPACESHIP
    constexpr auto operator<=>(const Foo&) const noexcept = default;
#else
    friend constexpr bool operator<(const Foo& a, const Foo& b) noexcept
    {
        return a.x < b.x || (a.x == b.x && a.y < b.y);
    }
#endif
};

using TestVariant = std::variant<Foo, int>;

constexpr Foo fooA { 0, 1 };
constexpr Foo fooB { 1, 0 };
constexpr std::variant<Foo, int> varA = fooA;
constexpr std::variant<Foo, int> varB = fooB;

static_assert(fooA < fooB);
static_assert(varA < varB);

https://godbolt.org/z/1zfq5dq1r

Observe que a asserção começa a passar quando uma das seguintes condições é atendida:

• use C++17 em vez de C++20
• use o operador de comparação de três vias em vez do operador de função livre menos
• não definindo conversão implícita para operador bool
• marcando o operador bool de conversão como explícito

Todos os compiladores têm o mesmo comportamento.

Eu tenho uma planilha com mais de 3k linhas e 15 colunas. Cada coluna é preenchida com um número aleatório de 1 a 25. Muito parecido com os resultados da loteria, onde cada coluna é um número sorteado na loteria. (de 1 a 25)

Preciso comparar se a sequência na linha 1 (para todas as 3k+ linhas) é encontrada em qualquer outra linha. Ou seja, se os resultados da loteria apareceram duas vezes. O problema é que a bola 1 pode aparecer em qualquer uma das 15 colunas diferentes.

A fórmula do Excel é uma fórmula que posso colocar na coluna a seguir? Ou um código VBA (idealmente) para comparar?

Meu aplicativo é um leitor de tela baseado em acessibilidade, mas alguns aplicativos bancários negam o funcionamento se meu serviço de acessibilidade estiver ativado. O usuário precisa desligá-lo explicitamente sempre que quiser usar o aplicativo bancário, o que está causando problemas.

Como faço para atenuar isso?

Pesquisei a documentação do Android o mais profundamente que pude, mas eles realmente não permitem que um aplicativo ignore a verificação do serviço de acessibilidade, pelo que pude ver.

É problemático e causa reclamações dos usuários. Procurando alguma solução para isso.

Estou usando a consulta react para buscar dados em uma postagem do blog, de acordo com seu ID. Quando visito uma determinada postagem do blog e navego para outra, primeiro ele me apresenta os dados da postagem anterior e, em seguida, renderiza novamente a página com as novas informações. Parece que os dados são primeiro obtidos do cache e depois atualizados.

Código:

const BlogPost = () => {
// Getting the blogPostId from the Url
  const { blogPostId } = useParams();

// Querying the blogPostData from the server using its id. (here is the problem probably...)
  const { data: blogPostData } = useQuery<BlogPostType>({
    queryKey: ["getBlogPost"],
    queryFn: () => apiClient.getPostById(blogPostId),
  });

  return (
    <div>
      <h1>{blogPostData?.title}</h1>
      <hr/>
      <p>{blogPostData?.description}</p>
    </div>
  );
};

Qualquer solução? (Quero que os novos dados apareçam imediatamente)

Atualmente estou criando um gráfico de dispersão com os resultados de algumas avaliações que estou fazendo.

Para obter um dataframe com a mesma estrutura que o meu, você pode executar:

import pandas as pd

models = ["60000_25_6", "60000_26_6"]

results = []
for i in range(10):
    for model in models:
        results.append({"simulation": i, "model_id": model, "count_at_1": 1, "count_at_5": 5, "count_at_10": 10})
df = pd.DataFrame(results)

Você acabará com um dataframe do pandas parecido com este, apenas com valores padrão (este é um dataframe menor, observe que o tamanho é variável e muito maior dependendo das configurações que eu uso):

    simulation    model_id  count_at_1  count_at_5  count_at_10
0            0  60000_25_6          60          77           84
1            0  60000_26_6          60          76           83
2            1  60000_25_6          69          80           82
...
18           9  60000_25_6           1          70           79
19           9  60000_26_6           1          68           74

Em seguida, uso o seguinte código para adicionar cores a cada ponto:

import matplotlib.pyplot as plt

colors = plt.get_cmap('hsv')
colors = [colors(i) for i in np.linspace(0,0.95, len(models))]
cmap = {model: colors[i] for i, model in enumerate(models)}

df['color'] = df.apply(lambda row: cmap[row['model_id']], axis=1)

E df agora é:

    simulation    model_id  count_at_1  count_at_5  count_at_10                 color
0            0  60000_25_6          74          81           83  (1.0, 0.0, 0.0, 1.0)
1            0  60000_26_6          75          80           83  (1.0, 0.0, 0.5, 1.0)
2            1  60000_25_6          71          84           89  (1.0, 0.0, 0.0, 1.0)
...
18           9  60000_25_6           2          69           79  (1.0, 0.0, 0.0, 1.0)
19           9  60000_26_6           2          72           78  (1.0, 0.0, 0.5, 1.0)

No entanto, quando corro:

df.plot.scatter('count_at_1', 'count_at_5', c='color', legend=True)

plt.show()

Nenhuma lenda aparece, apenas recebo um enredo normal assim:

Como posso adicionar uma legenda onde se pareça com:

[model_id]  [color]
...

Mas no formato matplotlib normal, vou levá-lo para qualquer lugar do gráfico.

Estou trabalhando em um pequeno programa python para mim e preciso de um algoritmo para multiplicação rápida de uma enorme matriz com números (mais de 660.000 números, cada um com 9 dígitos). O número do resultado tem mais de 4 milhões de dígitos. Atualmente estou usando math.prod, que calcula em aproximadamente 10 minutos, mas é muito lento, especialmente se eu quiser aumentar a quantidade de números.

Verifiquei alguns algoritmos para multiplicações mais rápidas, por exemplo o algoritmo de Schönhage-Strassen e a multiplicação de Toom-Cook, mas não entendi como eles funcionam ou como fazê-los. Tentei algumas versões que encontrei na internet, mas não funcionam muito bem e são ainda mais lentas. Gostaria de saber se alguém sabe como multiplicar essas quantidades de números mais rapidamente ou poderia explicar como usar um pouco de matemática para fazer isso?

Dado o parâmetro bash

foo='ab   "cd" "e f"  x="1 2" '

Desejo produzir um array equivalente a

foo_transformed=( ab '"cd"' '"e f"' 'x="1 2"' )

de forma portátil, ou seja, usar recursos internos do bash (v3 +) ou programas disponíveis para a maioria dos sistemas operacionais (Linux, Unix, Cygwin) por padrão. Simplicidade e segurança, dada a sequência de entrada (quase) arbitrária, são desejáveis.

Você pode assumir que a entrada não contém aspas simples 'ou barras invertidas \, mas pode conter um número arbitrário de caracteres de espaço em branco, tanto onde desejo que delimitem a string quanto onde não o fazem (quando entre aspas duplas).

Se tentarmos:

foo_transformed=( $foo )

então as aspas internas de foonão são respeitadas ( for k in "${foo_transformed[@]}"; do echo "- $k"; done):

- ab
- "cd"
- "e
- f"
- x="1
- 2"

Se tentarmos:

eval foo_transformed=( $foo )

então as aspas são perdidas:

- ab
- cd
- e f
- x=1 2

Substituí os métodos hashCodee equalsconforme abaixo e quero entender a implementação do método Map get.

public class Student{
    String name;

    Student(String s){
        this.name = s;
    }

    @Override
    public boolean equals(Object o) {
        return false;
    }

    @Override
    public int hashCode() {
        return 111;
    }

    public static void main(String[] args) {
        Map<Student,String> map=new HashMap<>();
        Student ob1=new Student("A");
        Student ob2=new Student("B");
        map.put(ob1,"A");
        map.put(ob2,"B");
        System.out.println(map.get(ob1));
    }
}

Tentei executar o resultado map.get()esperado nullporque a chave nunca será encontrada porque o equals()método sempre retornará falso, mas estou obtendo o resultado como Aneste caso.