All perguntas(coding)

Dada uma sequência composta de "a", "e", "i", "o" ou "u", encontre a maior subsequência de vogais em ordem. Por exemplo, se a sequência for "aeiaeiou", então a resposta é 6, tornando a subsequência "aaeiou". Outro exemplo é: "aeiaaioooaauuaeiou" onde a resposta é 10. Uma subsequência completa significa que você precisa ter todas as vogais em ordem, a -> e -> i -> o -> u, mas você pode ter repetições de vogais como "aaeeeeiiooouuu" é válido. Se nenhuma subsequência existir, retorne 0.

Eu criei uma abordagem DP de O(n^2) e estou curioso para saber se existe uma versão mais rápida para esse problema.

def find_longest_dp(vowels):
    n = len(vowels)
    dp = [[0, False] for _ in range(n)]
    prev_vowel = {"a": None, "e": "a", "i": "e", "o": "i", "u": "o"}

    for i in range(n):
        if vowels[i] == "a":
            dp[i] = [1, True]
        
        for j in range(i):
            if dp[j][1] and vowels[j] in {vowels[i], prev_vowel[vowels[i]]}:
                dp[i][0] = max(dp[i][0], dp[j][0] + 1)
                dp[i][1] = True
    
    return max((dp[i][0] for i in range(n) if vowels[i] == 'u'), default=0)

Estou tentando reordenar as colunas em um dataframe Polars e colocar 5 colunas de 100 primeiro (infelizmente, o documento deve ser legível no Excel). Não consigo encontrar uma maneira fácil de fazer isso.

Idealmente, eu gostaria de algo simples como

df.select(
    'col2',
    'col1',
    r'^.*$',  # the rest of the columns, but this throws a duplicate column name error
)

Lookahead negativo não é suportado, portanto não é possível criar um regex que exclua minhas colunas selecionadas. Eu poderia fazer duas seleções sobrepostas, eliminar as colunas de uma seleção e depois juntá-las, mas essa não parece ser a maneira pretendida de fazer isso. Todas as outras soluções que encontrei envolvem nomear explicitamente cada coluna, o que estou tentando evitar à medida que as colunas são adicionadas ou mudam de nome com certa frequência.

Meu objetivo: tenho um aplicativo macOS criado e quero...

1. Tem um botão para abrir o seletor de emojis (consegui isso)
2. Quando o usuário seleciona um emoji, intercepte esse valor comNSResponder
3. Em seguida, use-o na etiqueta do meu botão

O código abaixo é uma simplificação. Preciso de ajuda: Como posso interceptar o valor do NSResponder e imprimi-lo?

import SwiftUI
import AppKit

struct ContentView: View {
    private let emojiResponder = EmojiResponder()
    
    var body: some View {
        Button {
            // open the emoji picker
            if let window = NSApplication.shared.keyWindow {
                window.makeFirstResponder(emojiResponder)
                DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
                    NSApp.orderFrontCharacterPalette(nil)
                }
            }
        } label: {
            Text("Emoji?")
        }
        .onAppear {
            emojiResponder.onEmojiSelected = { selectedEmoji in
                print(selectedEmoji)
            }
        }
    }
}

// Custom Emoji NSResponder
class EmojiResponder: NSResponder {
    var onEmojiSelected: ((String) -> Void)?
    
    // use insertTest method from NSResponder
    // I assume this allows me to get the input 
    override func insertText(_ insertString: Any) {
        guard let selectedEmoji = insertString as? String else { return }
        onEmojiSelected?(selectedEmoji)
        print(selectedEmoji)
    }
}

Alguém pode me dar uma dica sobre como resolver isso? O que acontece agora: o seletor de emoji é aberto, mas nada acontece depois de selecionar um emoji

Observação: estou usando a solução desta discussão - https://stackoverflow.com/a/77797594/5133585 . Mas espero uma solução sem um TextField oculto.

A razão pela qual não quero usar um TextField aqui:

Eu tenho uma lista que percorre um array. Em cada linha, existem 3 TextFields: [emoji] —— [nome] —— [data]

Quando seleciono uma linha e pressiono Enter no macOS, ela se concentra no campo de texto emoji. O que eu quero é focar no nome TextField. Portanto, espero remover este emoji TextField e resolver esse problema.

Eu tenho uma string:

s = ".,-2gg,,,-2gg,-2gg,,,-2gg,,,,,,,,t,-2gg,,,,,,-2gg,t,,-1gtt,,,,,,,,,-1gt,-3ggg"

e uma expressão regular que estou usando

import re
delre = re.compile('-[0-9]+[ACGTNacgtn]+') #this is almost correct
print (delre.findall(s))

Isso retorna:

['-2gg', '-2gg', '-2gg', '-2gg', '-2gg', '-2gg', '-1gtt', '-1gt', '-3ggg']

Mas -1gtte -1gtnão são correspondências desejadas. O número inteiro, neste caso, define quantos caracteres subsequentes corresponderão, portanto, a saída desejada para essas duas correspondências seria -1ge -1g, respectivamente.

Existe uma maneira de capturar o número inteiro após o traço e definir dinamicamente o regex para que ele corresponda a esse número e apenas a esse número de caracteres subsequentes?

Dada a seguinte implementação de função:

function fmap<T, U>(value: T, f: (x: T) => U): U;
function fmap<T, U>(value: T | undefined, f: (x: T) => U): U | undefined;
function fmap<T, U>(value: T | null, f: (x: T) => U): U | null;
function fmap<T, U>(value: T | null | undefined, f: (x: T) => U): U | null | undefined {
    return value === undefined ? undefined : value === null ? null : f(value);
}

Eu obtenho os tipos corretos nos seguintes casos:

const test1 = (v: string) => fmap(v, x => x); // ✅ expected: string
const test2 = (v: string | null) => fmap(v, x => x); // ✅ expected: string | null
const test3 = (v: string | undefined) => fmap(v, x => x); // ✅ expected: string | undefined
const test4 = (v: string | null | undefined) => fmap(v, x => x); // ✅ expected: string | null | undefined
const test5 = (v: string) => fmap(v, x => 1); // ✅ expected: number

Mas não nestes casos:

// ❌ expected: number | null (actual: number)
const test6 = (v: string | null) => fmap(v, x => 1);

// ❌ expected: number | undefined (actual: number)
const test7 = (v: string | undefined) => fmap(v, x => 1);

// ❌ expected: number | null | undefined (actual: number)
const test8 = (v: string | null | undefined) => fmap(v, x => 1);

Veja Parque Infantil

Tenho o seguinte exemplo de estrutura de dados de cliente que pode fazer parte de vários grupos usando uma tabela de junção e dados:

CREATE TABLE customer(id) AS VALUES (0),(1),(2),(3);
CREATE TABLE groups(id)   AS VALUES (1),(3),(5),(6);
CREATE TABLE customers_to_groups(customer_id, group_id) AS
  VALUES (0, 1)--customer 0 is in group (5 OR 6) AND (1 OR 3)
        ,(0, 5)--customer 0 is in group (5 OR 6) AND (1 OR 3)
        ,(1, 1)
        ,(1, 90)
        ,(2, 1)
        ,(3, 3)--customer 3 is in group (5 OR 6) AND (1 OR 3)
        ,(3, 5)--customer 3 is in group (5 OR 6) AND (1 OR 3)
        ,(3, 90);

Preciso obter clientes que tenham grupos específicos dos quais fazem parte e preciso obter uma lista de todos os clientes que fazem parte de pelo menos um grupo em várias listas de grupos. Por exemplo eu quero pegar todos os clientes que estão no grupo (5 OR 6) AND (1 OR 3), então por exemplo um cliente nos grupos 5 e 1 seria retornado, mas alguém no grupo 1 e 90 ou apenas no grupo 1 não. Com os dados de amostra fornecidos, obteríamos o cliente com os IDs 0 e 3 apenas se eles estivessem em conformidade com as regras fornecidas acima.

Apenas fazer WHERE group_id IN (5,6) AND group_id IN (1,3)não parece funcionar, então estou procurando uma alternativa.

Eu tenho isso até agora que funciona:

SELECT DISTINCT c.id
FROM customer c
INNER JOIN customers_to_groups at1 ON c.id = at1.customer_id
INNER JOIN customers_to_groups at2 ON c.id = at2.customer_id
WHERE at1.group_id IN (5, 6)
  AND at2.group_id IN (1, 3);

Resultados esperados:

Existe uma maneira de fazer isso com mais desempenho?

Em julho de 2024, o vscode (atualização 1.92) introduziu este novo gráfico de alterações de receita/saída:

Na verdade, não preciso disso, pois uso outra ferramenta para isso e ela está poluindo meu espaço de trabalho.

Existe uma maneira de remove-lo? Tentei clicar mas não consegui encontrar. As notas de atualização também não especificam uma maneira de desativar esse recurso.

A seguir está um trecho de C++ que demonstra uma classe Fooque agrupa a std::optional<double>, fornecendo operadores de conversão para doublee std::optional<double>.

#include <iostream>
#include <optional>

class Foo {
public:
  operator double() const {
    std::cout << "Foo::operator double()" << std::endl;
    return {};
  }

  operator std::optional<double>() const {
    std::cout << "Foo::operator std::optional<double>()" << std::endl;
    return {};
  }
};

int main() {
  Foo foo;
  std::optional<double> value;
  
  // Outputs "Foo::operator double()"
  value = foo; 
}

Surpreendentemente para mim, ao atribuir uma instância de Fooa a std::optional<double>, o operador de conversão for doubleé chamado em vez do operador de conversão for std::optional<double>.

Quando substituo std::optionalpor minha própria Optionalclasse personalizada, como você pode ver abaixo, o compilador seleciona o outro operador de conversão.

#include <iostream>

template<class T>
class Optional {
public:
  T val;
  
  Optional() = default;
  
  Optional(T) {
    std::cout << "Optional(T)" << std::endl;
  }
  
  Optional(Optional&&) noexcept {
    std::cout << "Optional(Optional&&)" << std::endl;
  }

  Optional(const Optional<T>&) {
    std::cout << "Optional(const Optional&)" << std::endl;
  }

  Optional& operator=(Optional&&) noexcept {
    std::cout << "Optional::operator=(Optional&&)" << std::endl;
    return *this;
  }

  operator const T& () const {
    std::cout << "Optional::operator const T&()" << std::endl;
    return val;
  }
};

class Foo {
public:
  operator double() const {
    std::cout << "Foo::operator double()" << std::endl;
    return {};
  }

  operator Optional<double>() const { 
    std::cout << "Foo::operator Optional<double>()" << std::endl;
    return {};
  }
};

int main() {
  Foo foo;
  Optional<double> value;

  // Outputs
  //   Foo::operator Optional<double>()
  //   Optional::operator=(Optional&&)
  value = foo;
}

Por que o compilador seleciona um operador de conversão diferente em cada cenário?

Abaixo está uma expressão lambda recursiva que pode calcular os valores da sequência de Fibonacci tanto em tempo de execução quanto durante a avaliação constante:

auto fib = [](this auto && f, auto && p) {
    if ( p < 3 ) return 1;
    decltype(+p) v{};
    v = p - 2;
    return f(v+1) + f(v);
};

// ok everywhere
static_assert( fib(1) == 1 );
static_assert( fib(2) == 1 );
static_assert( fib(3) == 2 );
static_assert( fib(4) == 3 );
static_assert( fib(5) == 5 );
static_assert( fib(6) == 8 );
static_assert( fib(7) == 13 );
static_assert( 20 <= fib(8) && fib(8) <= 21 );
// fails in MSVC
static_assert( fib(8) == 21 );

Pelo que posso ver, funciona bem no GCC e no Clang, mas no Visual Studio funciona apenas para os primeiros 7 elementos e fib(8)é calculado de forma imprecisa, resultando em uma falha na asserção estática. Demonstração online: https://gcc.godbolt.org/z/dMM6f16do

Se o programa estiver correto, por que ele funciona bem para números pequenos e não funciona para números maiores (por exemplo, estouro de inteiros, muitas chamadas recursivas)?

Digamos que eu tenha uma série de permutações permque poderiam ser assim:

perm = np.array([[0, 1, 2], [1, 2, 0], [0, 2, 1], [2, 1, 0]])

Se eu quiser aplicá-lo a um eixo, posso escrever algo como:

v = np.arange(9).reshape(3, 3)
print(v[perm])

Saída:

array([[[0, 1, 2],
        [3, 4, 5],
        [6, 7, 8]],

       [[3, 4, 5],
        [6, 7, 8],
        [0, 1, 2]],

       [[0, 1, 2],
        [6, 7, 8],
        [3, 4, 5]],

       [[6, 7, 8],
        [3, 4, 5],
        [0, 1, 2]]])

Agora gostaria de aplicá-lo a dois eixos ao mesmo tempo. Eu descobri que posso fazer isso através de:

np.array([v[tuple(np.meshgrid(p, p, indexing="ij"))] for p in perm])

Mas acho isso bastante ineficiente, porque precisa criar uma grade de malha e também requer um loop for. Criei um array pequeno neste exemplo, mas na realidade tenho arrays muito maiores com muitas permutações, então adoraria ter algo que fosse tão rápido e simples quanto a versão de um eixo.