All perguntas(coding)

Semelhante a este , mas não totalmente.

Tenho um produto de assinatura variável que pode ser pago em 12 parcelas mensais.

se "Número de parcelas" for "Pagar integralmente", gostaria de poder alterar o texto £xxx para 1 mês:

E então mantenha as próximas 11 parcelas como para 2 meses / 3 meses, etc.

Sei que esse código só mostrará os preços, mas não consigo modificá-lo para alterar apenas 1 mês (opção de pagamento integral):

add_filter('woocommerce_subscriptions_product_price_string_inclusions', 'remove_subscription_inclusions', 10, 2);

function remove_subscription_inclusions( $include, $product ) {
    $include['subscription_length'] = '';
    $include['subscription_period'] = '';
    return $include;
}

Eu tentei isso, mas não teve efeito algum:

add_filter('woocommerce_subscriptions_product_price_string_inclusions', 'custom_subscription_price_string_inclusions', 10, 2);

function custom_subscription_price_string_inclusions( $include, $product ) {
    // Check if the product is a subscription product
    if ($product->is_type('subscription')) {
        // Get the variations of the subscription product
        $variations = $product->get_available_variations();

        // Loop through each variation to check for the 1-month payment option
        foreach ($variations as $variation) {
            // Get the variation's price and subscription length/period
            $regular_price = $variation['display_price'];
            $subscription_length = isset($variation['attributes']['pa_subscription_length']) ? $variation['attributes']['pa_subscription_length'] : '';
            $subscription_period = isset($variation['attributes']['pa_subscription_period']) ? $variation['attributes']['pa_subscription_period'] : '';

            // Check if this variation is the 1 month (single payment) option
            if ('1' === $subscription_length && 'month' === $subscription_period) {
                // Modify the price string for the 1 month single payment option
                $include['price_string'] = '£' . $regular_price . ' (Full payment for 1 month)';
                // Remove subscription length and period to avoid duplication
                $include['subscription_length'] = '';
                $include['subscription_period'] = '';
            }
        }
    }

    return $include;
}

Minha tarefa é criar uma scrollview, que recebe um array de strings e uma sobreposição, localizada no centro. Quando alguma visualização entra nessa sobreposição, ela deve se alinhar imediatamente às suas bordas, ou seja, estar no centro da tela. A lista deve começar no meio da tela com o primeiro elemento. Eu estava procurando uma solução aqui .

Eu tenho estrutura

struct Region: Equatable, Hashable {
    let name: String
}

Estrutura de Chave de Preferência

struct ViewOffsetKey: PreferenceKey {
    static var defaultValue: [String: CGRect] = [:]
    
    static func reduce(value: inout [String: CGRect], nextValue: () -> [String: CGRect]) {
        value.merge(nextValue(), uniquingKeysWith: { $1 })
    }
}

e subView

struct RegionView: View {
    
    let name: String
    
    var body: some View {
        HStack {
            Text(self.name)
                .foregroundColor(.white)
                .font(.system(.body))
            
            Spacer()
        }
        .padding(16)
        .frame(width: 348, alignment: .topLeading)
        .background(Color.black)
        .cornerRadius(50)
        .id(name)
        .background(GeometryReader {
            Color.clear.preference(key: ViewOffsetKey.self,
                                   value: [name: $0.frame(in: .global)])
        })
    }
}

A visualização principal é realizada por meio de CurrentValueSubject e AnyPublisher. Verifico se a subView intercepta um retângulo com altura 1 e, em seguida, a escrevo como exibida. Quando a rolagem termina, chamo o método scrollTo.

struct RegionListView: View {
    let detector: CurrentValueSubject<[String: CGRect], Never>
    let publisher: AnyPublisher<[String: CGRect], Never>
    
    let regions: [Region] = [
        Region(name: "Region 1"),
        Region(name: "Region 2"),
        Region(name: "Region 3"),
        Region(name: "Region 4"),
        Region(name: "Region 5"),
        Region(name: "Region 6"),
        Region(name: "Region 7"),
        Region(name: "Region 8"),
        Region(name: "Region 9"),
        Region(name: "Region 10"),
        Region(name: "Region 11"),
        Region(name: "Region 12"),
        Region(name: "Region 13"),
        Region(name: "Region 14"),
        Region(name: "Region 15"),
        Region(name: "Region 16"),
        Region(name: "Region 17"),
        Region(name: "Region 18"),
        Region(name: "Region 19"),
        Region(name: "Region 20"),
    ]
    
    @State private var topVisibleChildId: String?
    
    init() {
        let detector = CurrentValueSubject<[String: CGRect], Never>([:])
        self.publisher = detector
            .debounce(for: .seconds(0.1), scheduler: DispatchQueue.main)
            .dropFirst()
            .eraseToAnyPublisher()
        self.detector = detector
    }
    
    var body: some View {
        GeometryReader { geometryReader in
            ScrollViewReader { proxy in
                ScrollView {
                    VStack(spacing: 8) {
                        ForEach(self.regions, id: \.self) { region in
                            RegionView(name: region.name)
                        }
                    }
                    .frame(maxWidth: .infinity)
                    .onPreferenceChange(ViewOffsetKey.self) { childFrames in
                        detector.send(childFrames)
                        
                        var visibleChildIds = [String]()
                        let screenMid = geometryReader.size.height / 2 + 56
                        
                        for (id, childFrame) in childFrames where childFrame.intersects(CGRect(x: 0, y: Int(screenMid), width: .max, height: 56)) {
                            print("id \(id) childFrame \(childFrame)")
                            visibleChildIds.append(id)
                        }
                        
                        visibleChildIds.sort()
                        
                        if let first = visibleChildIds.first {
                            topVisibleChildId = first
                        }
                    }
                }
                .safeAreaPadding(.top, geometryReader.size.height / 2 - 28)
                .safeAreaPadding(.bottom, geometryReader.size.height / 2 - 28)
                .background(Color.black)
                .onReceive(publisher) { _ in
                    proxy.scrollTo(topVisibleChildId, anchor: .center)
                }
                .overlay(
                    Text("Top Visible Child: \(topVisibleChildId ?? "")")
                        .padding()
                        .background(Color.blue.opacity(1))
                        .foregroundColor(.white)
                        .cornerRadius(10),
                    alignment: .top
                )
                
                .overlay(
                    Rectangle()
                        .frame(maxWidth: .infinity)
                        .frame(height: 56)
                        .foregroundColor(Color.clear)
                        .border(.green, width: 4),
                    alignment: .center
                )
            }
        }
    }
}

Minha pergunta: é possível implementar um comportamento em que a mudança de células seja semelhante à escolha de um horário ao definir um alarme? Ou seja, a célula não precisará ser rolada para o centro se o usuário não terminar de rolar no meio. Espero ter explicado claramente.

Acho que isso não é possível, mas pergunto mesmo assim.

Dada uma macro x como a seguinte:

#define X_TABLE(_)\
  _(1, a, "hi")\
  _(2, b, "hello")\
  _(3, c, "sup")

// ...

#define X(_1, _2, _3) SomeFunc(_1, _2, _3);
X_TABLE(X)
#undef X

O acima geraria:

SomeFunc(1, a, "hi");
SomeFunc(2, b, "hello");
SomeFunc(3, c, "sup");

Existe uma maneira de pular algumas linhas de X_TABLEna avaliação de X, de modo que SomeFuncnão seja gerado para essa linha?

Talvez, gere algo assim:

SomeFunc(1, a, "hi");
SomeFunc(3, c, "sup");

Esta é uma ideia de como fica minha mesa -

É assim que os dados podem ficar, onde um país pode ter várias linhas com o mesmo número (não uma chave primária) e valor na coluna "país". Haverá várias linhas com vários idiomas e seus respectivos nomes traduzidos.

Preciso obter uma saída onde eu possa exibir todas as informações acima e, adicionalmente, uma nova coluna chamada "por exemplo", nameque sempre será o valor em "translatedName" para o language en. Algo assim:

Alguma ideia de como posso fazer isso — talvez usando condições (CASE) ou autojunção? Qualquer ajuda é bem-vinda!

CREATE FUNCTION create_user_if_not_exists(_name text, _pass text)
  RETURNS void AS
$func$
DECLARE
   _dbname TEXT := concat(_name, '_db');
BEGIN
    IF EXISTS (SELECT FROM pg_catalog.pg_roles WHERE rolname = _name) THEN
       RAISE NOTICE 'Role already exists. Skipping.';
    ELSE
     CREATE USER _name WITH encrypted password '_pass';
     GRANT ALL PRIVILEGES ON DATABASE _dbname TO _name;
    END IF;
END
$func$ LANGUAGE plpgsql;

Quando eu corro:

psql --username "$POSTGRES_USER" -c "SELECT create_user_if_not_exists('Foo', 'BAR');"

Eu entendo:

ERROR:  database "_dbname" does not exist

Se eu comentar a GRANT ALLparte, acabo com um usuário chamado _nameem pg_catalog.pg_roles. Suspeitei _que fosse o responsável por isso, mas o mesmo acontece com várias sintaxes. Adicionar _namee _passnão DECLAREmuda nada.

Por que _name, _passe são _dbnameinterpretados como valores em vez de variáveis ​​próprias neste contexto? É uma questão de definição de função, algumas restrições em GRANTe CREATEou por causa da maneira como chamo esta função com psql?

Depois de ler isto e isto , não consigo entender a diferença entre explicar o que está errado.

Ambiente:psql (PostgreSQL) 17.4 (Debian 17.4-1.pgdg120+2)

Há um armazenamento de dados para leitura e gravação de dados em um dicionário. Estou usando um ator global que garante a execução de operações em série.

Exemplo de código:

@globalActor
struct DataStorageActor {
    actor ActorType { }
    static let shared: ActorType = ActorType()
}

@DataStorageActor
class CustomDataStorage {
    private var storage: [String: String] = [:]
    
    func write(key: String, value: String) async throws {
        print("\(Date()): Write started")
        try await Task.sleep(nanoseconds: 5_000_000_000)
        storage[key] = value
        print("\(Date()): Write completed for key: \(key)")
    }
    
    func read(key: String) async throws -> String? {
        print("\(Date()): Read started")
        let value = storage[key]
        print("\(Date()): Read completed for key: \(key)")
        return value
    }
}

E um teste unitário foi escrito:

    @Test(arguments: ["Very long string"])
    func testSerialExecution(input: String) async throws {
        let storage = CustomDataStorage()

        let task1 = Task {
            try await storage.write(key: "test", value: input)
        }

        let task2 = Task {
            try await Task.sleep(nanoseconds: 2_000_000_000)
            
            let value = try await storage.read(key: "test")
            print("\(Date()): Received value: \(value ?? "nil")")
            
            return value
        }
        
        print("wait task 1")
        _ = try await task1.value
        
        print("wait task 2")
        let value: String? = try await task2.value
        
        print("check result")
        #expect(value == input)
    }

1. Em um thread separado, eu lanço uma longa operação de gravação (5 segundos)
2. Em um thread separado, eu lanço uma operação de leitura com um atraso de 2 segundos
3. Espero que a operação de leitura aguarde a conclusão da operação de gravação

Mas a operação de leitura é executada em paralelo, registra:

wait task 1
2025-04-07 12:43:03 +0000: Write started
2025-04-07 12:43:05 +0000: Read started
2025-04-07 12:43:05 +0000: Read completed for key: test
2025-04-07 12:43:05 +0000: Received value: nil
2025-04-07 12:43:08 +0000: Write completed for key: test
wait task 2
check result

Por que funciona assim?

Projeto C++ no Linux usando Conan (v2) para dependências. Ao usar o pacote Conan libavrocpp/1.11.3 em conanfile.py:

def requirements(self):
    self.requires("libavrocpp/1.11.3")

def build_requirements(self):
    self.tool_requires("libavrocpp/1.11.3")

Mais tarde, quero usar a ferramenta avrogencpp do pacote para gerar classes C++ a partir dos meus esquemas avro durante o CMake.

Vejo que a ferramenta existe (em vários lugares) no cache local do Conan (~/.conan2) e preciso referenciá-la de alguma forma a partir daí. Eu poderia simplesmente codificar o caminho para avrogencpp nos meus arquivos do CMake, mas isso não funcionaria na próxima vez que eu atualizasse o pacote para uma versão mais recente ou os autores do Conan modificassem o layout do cache (o layout do cache é proprietário e sujeito a alterações). Então:

Qual é a maneira correta (específica da versão) de referenciar a ferramenta avrogencpp a partir de um arquivo CMake ao usar o pacote Conan? Existe algum símbolo definido em algum lugar que aponte para ela?

(O CMake tem FindProtobuf, que define símbolos, incluindo um que aponta para o compilador protoc específico da versão. Existe algo semelhante para o Avro? Não encontrei até agora...)

Como posso fechar a conexão WebSocket aberta pelo Hyperledger Caliper ?

Meu config.json se parece com isso

{
    "caliper": {
        "blockchain": "ethereum"
    },
    "ethereum": {
        "url": "ws://<ws_url>",
        "nonceManager": "managed",
.......
}

Parece que cada trabalhador abre uma conexão WebSocket e não a fecha mesmo após a execução bem-sucedida do teste.

await using (var streamReader = File.OpenRead(filePath))
using (var reader = new StreamReader(streamReader))
{
    while ((line = await reader.ReadLineAsync()) != null)
    {
      // my logic
    }
}

No exemplo de código acima, o compilador C# 13 sugere usar 'await using' em vez de usar para o leitor de fluxo. No entanto, o tipo de retorno de File.OpenRead() não é uma tarefa. Por quê? Eu pensei que apenas tarefas precisassem ser aguardadas.

Entendo o await para ReadLineAsync(), pois este é um método assíncrono que retorna uma tarefa. Mas não faz sentido para mim para OpenRead().

Estou trabalhando em um problema para um jogo simulado. Quero que minha IA seja capaz de mirar em um alvo inimigo em movimento com uma determinada localização inicial, velocidade inicial e aceleração constante.

A posição do inimigo é dada por

p_e(t) = s_e + v_e * t + 0.5 * a_e * t ** 2

e a posição de um projétil disparado é dada por

v_b(theta) = spd_b * (sin(theta), cos(theta))
p_b(theta, t) = v_b(theta) * t

A tarefa é encontrar o ângulo thetatal que haja algum tlugar p_e(t) == p_b(t), se houver algum, thetadados os valores dos vários parâmetros.

Resolvi a versão com aceleração zero usando o Sympy. A saída do Sympy pareceu logicamente correta e funcionou corretamente na simulação que estou usando. No entanto, quando tentei resolver a versão com aceleração, tive problemas:

from sympy import *

# Define variables.
#
# Note: we do not define variables for the bullet's starting position, because
# we are going to treat the player ship as a fixed frame of reference.
# Therefore, esx, esy, evx, and evy need to be modified by the controlled
# ship's relative speed and position.
esx, esy, evx, evy, eax, eay = symbols('esx esy evx evy eax eay')
bspd, theta = symbols('bspd theta')
bvx, bvy = bspd * sin(theta), bspd * cos(theta)
t = symbols('t', positive=True)

# Define the x and y positions of the bullet and the enemy.
ex = esx + evx * t + 0.5 * eax * t ** 2
ey = esy + evy * t + 0.5 * eay * t ** 2
bx = bvx * t
by = bvy * t

# Solve for the intersection time in each dimension.
tix = solve(Eq(ex, bx), t)
tiy = solve(Eq(ey, by), t)
print(tix)
print(tiy)

# Set the per-dimension intersection times equal to one another 
# and solve for theta.
print(solve(Eq(tix[0], tiy[0]), theta, check=False))

A saída deste programa é:

[(bspd*sin(theta) - evx - 1.4142135623731*sqrt(0.5*bspd**2*sin(theta)**2 - bspd*evx*sin(theta) - eax*esx + 0.5*evx**2))/eax, (bspd*sin(theta) - evx + 1.4142135623731*sqrt(0.5*bspd**2*sin(theta)**2 - bspd*evx*sin(theta) - eax*esx + 0.5*evx**2))/eax]
[(bspd*cos(theta) - evy - 1.4142135623731*sqrt(0.5*bspd**2*cos(theta)**2 - bspd*evy*cos(theta) - eay*esy + 0.5*evy**2))/eay, (bspd*cos(theta) - evy + 1.4142135623731*sqrt(0.5*bspd**2*cos(theta)**2 - bspd*evy*cos(theta) - eay*esy + 0.5*evy**2))/eay]
[-oo*I, oo*I]

Quando executo este código, a impressão final mostra que a solução contém infinito vezes um número imaginário. Agora, tixe tiytenho duas soluções, mas obtenho este resultado independentemente da combinação de soluções que uso.

Não sou um especialista em matemática, e é por isso que estou tentando usar o Sympy para resolver isso. Será que adicionar o termo de aceleração torna realmente impossível resolver este problema? Ou fiz algo errado ao usar o Sympy? Se fiz algo errado ao usar o Sympy, por favor, me digam o que é e como consertar.