All perguntas(coding)

Tenho uma lista de inteiros com duplicatas e preciso classificá-la pelo número dessas duplicatas.

Por exemplo:

input: n = [2, 4, 1, 2]
output: n = [4, 1, 2, 2]

Eu escrevi um código e notei que sort() não altera a lista. Mas se eu tentar usar sorted() com o mesmo argumento de chave, então funciona perfeitamente. Qual é a razão por trás disso?

Meu código:

nums = [2, 4, 1, 2]
nums.sort(key = lambda x: nums.count(x))
print(nums)

Ele pode ser conectado ao método sort() usando o algoritmo in-loco?

O código a seguir vem do GCC Wiki .

// -Thread 1-
y.store (20, memory_order_relaxed)
x.store (10, memory_order_relaxed)

// -Thread 2-
if (x.load (memory_order_relaxed) == 10)
 {
   assert (y.load(memory_order_relaxed) == 20) /* assert A */
   y.store (10, memory_order_relaxed)
 }

// -Thread 3-
if (y.load (memory_order_relaxed) == 10)
 assert (x.load(memory_order_relaxed) == 10) /* assert B */

Como os threads não precisam ser sincronizados no sistema, qualquer uma das asserções neste exemplo pode realmente FALHAR .

Eu consigo entender por que assert A pode falhar. Mas como assert B também pode falhar?

Isso y.load() == 10implica o fim do tópico 2, então x.load() == 10?

Estou com dificuldades para entender a definição de templates. Meu entendimento básico é que as definições de templates permitem tornar o tipo de dados para retorno ou argumentos como genérico. Ou seja, um argumento de template é um tipo de dados para o qual o compilador instancia e vincula em tempo de compilação,

Mas não consigo entender definições complexas como as abaixo:

#include <iostream>
#include <type_traits>

template <unsigned n>
struct factorial : std::integral_constant<int,n * factorial<n-1>::value> {};

template <>
struct factorial<0> : std::integral_constant<int,1> {};

int main() {
  std::cout << factorial<5>::value;  // constexpr (no calculations on runtime)
  return 0;
}

onde

template <class T, T v>
struct integral_constant {
  static constexpr T value = v;
  typedef T value_type;
  typedef integral_constant<T,v> type;
  constexpr operator T() { return v; }
};

Saída:

120

É realmente difícil visualizar como os modelos são instanciados:

template <int,5 * factorial<5-1>::value>
struct integral_constant {
  static constexpr int value = 5 * factorial<5-1>::value;
  typedef int value_type;
  typedef integral_constant<5 * factorial<5-1>::value> type;
  constexpr operator int() { return 5 * factorial<5-1>::value; }
};

#include <iostream>
#include <vector>

class Car{
  public:
    int weight;

    Car(int weight): weight(weight){
      
    };

    Car(const Car& other){
        std::cout<<"copied!"<<std::endl;
        this->weight=other.weight;
    }
};

int main() {
    std::vector<Car> vec;
    vec.push_back(Car(1));
    return 0;
}

No código acima, de alguma forma, quando eu empurro Car(1) para vec, o construtor de cópia na classe Car é chamado. Por que o construtor de cópia é chamado? Não estou copiando nada aqui.

Todos os exemplos que encontrei de chamada de um método Java de C usando a API Foreign Function & Memory envolvem retornos de chamada, ou seja, um método Java que executa alguma função nativa com um retorno de chamada Java como parâmetro.

E quanto a C chamando um método Java diretamente? JNI ainda é a única maneira de fazer isso?

Estou tentando consultar uma tabela para encontrar todas as instâncias em que um caractere se repete pelo menos 5 vezes seguidas.

Eu tentei:

Select Column
From Table
where Column REGEXP '(.)\1{4,}'

mas não retorna nada.

A tabela inclui as seguintes entradas que DEVEM ser retornadas:

1.111111111111E31
00000000000000000
xxxxxxxxxxxxxxxxx

Estou usando Java 8 e estou enfrentando um erro estranho.

O compilador dá o seguinte erro:

erro: a referência a [método] é ambígua

Aqui está meu código

StringBuilder sb = new StringBuilder();
Stack<Integer> st = new Stack<>();
st.push(123);

sb.append(st.size() > 0 ? st.pop() : 0);

Depois de alguma pesquisa, descobri que Java converte o operador ternário ? Integer:intpara int. Além disso, a sobrecarga de resolução prefere append(int i)( append(Object o)unboxing).

Pelo que entendi, o código não deve causar nenhum erro.

1. tipo de operador ternário deve ser int, nãoInteger
2. Mesmo que o resultado seja Integer, append(int i)deve ser invocado devido à sobrecarga de resolução

Portanto, não há razão para causar ambiguidade

Isso é estranho e só ocorre com Java 8 (não 11, 17 - eu tentei)

E uma coisa ainda mais estranha é que esse código funciona

sb.append(st.size() <= 0 ? 0 : st.pop());

Alguém pode explicar o porquê? Ou me diga se há algo que eu perdi

Tentei encontrar problemas em como o operador ternário e a resolução de sobrecarga funcionam, mas, conforme investiguei, não há razão para causar erro.

(talvez o título já se enquadre no problema XY...)

Dada esta função modelada:

template <typename T, typename U, typename V, typename W>
void MyFunc()
{
    // stuff...
}

Gostaria de chamá-lo para todas as combinações dadas de tipos. Por exemplo, gostaria de chamar para:

• T: char, int, longo longo
• U: flutuar, duplo
• V: std::uint64_t, std::string_view
• W: int, MeuEnum1, MeuEnum2, MeuEnum3

Em pseudocódigo, ficaria assim:

foreach (t in { char, int, long long })
{
    foreach (u in { float, double })
    {
        foreach (v in { std::uint64_t, std::string_view })
        {
            foreach (w in { int, MyEnum1, MyEnum2, MyEnum3 })
            {
                MyFunc<t, u, v, w>();
            }
        }
    }
}

Como posso conseguir isso?

Acredito que truques/padrões de modelos variáveis, como tuplas ou "listas de tipos", são o caminho a seguir, mas não consegui resolvê-los.

Dada a seguinte configuração,

N_r = 21; N_theta = 18; N_phi= 36;
r_index = N_r-1;

[phi,theta,r_sphere] = np.meshgrid(np.linspace(0,2*np.pi,N_phi),np.linspace(0,np.pi,N_theta),np.linspace(a,b,N_r));

X = r_sphere[:,:,r_index] * np.sin(theta[:,:,r_index]) * np.cos(phi[:,:,r_index]);
Y = r_sphere[:,:,r_index] * np.sin(theta[:,:,r_index]) * np.sin(phi[:,:,r_index]);
Z = r_sphere[:,:,r_index] * np.cos(theta[:,:,r_index]);

rho = 1/r_sphere**2*np.sin(theta)*np.cos(theta)*np.sin(phi)

Configurei minhas coordenadas 2D X, Y e Z convertidas de coordenadas esféricas e uma variável de densidade em coordenadas esféricas da qual desejo plotar uma casca esférica (em r_index). No Matlab, com as mesmas variáveis ​​e configuração, consegui usar a surf()função

surf(X,Y,Z,rho(:,:,r_index),"EdgeAlpha",0.2);(além de algumas outras coisas como rótulos de eixo e barra de cores), consegui criar o seguinte gráfico 3D (ou acho que 4D?) em r=r_index:

Tentar usar o Matplotlib plot_surface()ou não funciona, ou não estou obtendo minhas entradas corretamente:

fig1 = plt.figure(figsize=(16,9),dpi=80)
ax = fig1.add_subplot(projection = "3d")
surf = ax.plot_surface(X,Y,Z,rho[:,:,r_index])

Posso fazer isso funcionar usando plot_surface()ou existe outra função de plotagem feita sob medida para o que estou tentando fazer?

EDIT: scatter()parece me dar algo próximo

fig1 = plt.figure(figsize=(16,9),dpi=80)
ax = fig1.add_subplot(projection = "3d")
surf = ax.scatter(X,Y,Z,c=rho[:,:,r_index],cmap = mpl.colormaps['bwr'])
plt.colorbar(surf,ax = ax,shrink = 0.5,aspect = 5)
plt.show()

Ele habilmente configura a forma da superfície ao pegar X, Y e Z, e então eu posso definir c para colorir cada ponto de acordo com o intervalo de valores passados. Se eu pudesse fazer algo similar a isso para uma função como plot_surface(). Provavelmente pode ser feito, eu só não sei quais seriam os argumentos de entrada exatos.

No pacote Rust fastnum de ponto flutuante decimal de alta precisão, dividir por zero causa pânico por padrão. Justo.

Mas o fastnum lista especificamente entre seus recursos o suporte para semântica completa de ponto flutuante, incluindo +/- Inf: https://www.reddit.com/r/rust/comments/1hk61om/announcing_a_new_fast_exact_precision_decimal/

Como você faz a divisão render Inf em vez de pânico? A documentação não diz.