All perguntas(coding)

Não tenho certeza do que estou fazendo errado, mas quando executo o código abaixo:

func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
    let length = nums.count-1;

    for index1 in 0...length {
        let difference = target - nums[index1];
        print(target, difference, nums[index1])
        if (nums[index1] < difference) {
            for index2 in index1+1...length {
                if (nums[index2] == difference) {
                    return [index1, index2];
                }
            }
        }
    } 

    return [];
}

let summer = twoSum([-1,-2,-3,-4,-5], -8)

Recebo o seguinte erro:

Swift/ClosedRange.swift:347: Erro fatal: O intervalo requer lowerBound <= upperBound

Curiosamente, se eu alterar a condição da instrução if para nums[index1] <= target, ela não trava.

Tenho uma pergunta muito parecida com esta, mas 1) quero que isso funcione para uma série também e 2) não tenho uma coluna representando meus valores de agrupamento; os valores estão no índice.

Imagine que eu tenho uma série que se parece com o seguinte:

2023-08-01    1515000.08
2023-09-01    2629410.80
2023-10-01    2548748.40
2023-11-01    2494398.04
2023-12-01    3397805.34
2024-01-01    3285501.49
2024-02-01    3173978.74
2024-03-01    3139235.65
2024-04-01    2927895.84
2024-05-01    2750708.29
dtype: float64

Gostaria de criar uma nova Série onde os valores representam o valor do último mês do trimestre anterior , assim:

2023-08-01    NaN
2023-09-01    NaN
2023-10-01    2629410.80 <--- the old value from 2023-09-01, which was the end of Q3
2023-11-01    2629410.80
2023-12-01    2629410.80
2024-01-01    3397805.34 <--- the old value from 2023-12-01
2024-02-01    3397805.34
2024-03-01    3397805.34
2024-04-01    3139235.65 <--- the old value from 2024-03-01
2024-05-01    3139235.65
dtype: float64

Estou achando muito difícil encontrar uma solução elegante aqui. Meu código é mais ou menos assim:

period_to_val = (
    series.groupby(
        lambda x: get_quarter(date=x)
    )
    .last()
    .shift()
)

data = series.index.map(
    lambda x: period_to_val[get_end_of_period(date=x, term_length=term_length, fiscal_year_start=fiscal_year_start)]
)

result = pd.Series(data=data, index=series.index)

Mas isso parece muito prolixo e feio. Eu queria uma operação no SeriesGroupByque fosse uma mistura entre a .shift()e a .transform("last"), mas tal coisa parece não existir.

Alguma ideia de como melhorar? Obrigado!

Por que meu make testnão está funcionando?

Eu tenho esse makefile simples e ao executar

# make test
make: 'test' is up to date.

De onde vem 'test' is up to date.!?

makefile

BINARY_HTTP=http

build:
    @go build -o bin/${BINARY_HTTP} cmd/${BINARY_HTTP}/main.go

run: build
ifdef skip-user
    @./bin/${BINARY_HTTP}/main -skip-user
else
    @./bin/${BINARY_HTTP}/main
endif

test:
    @echo "test"
    @go test -count=1 ./test

Se o testcomando no makefile for alterado para algo parecido, weeo comando funciona? Por quê?

# make wee
test

makefile

BINARY_HTTP=http

build:
    @go build -o bin/${BINARY_HTTP} cmd/${BINARY_HTTP}/main.go

run: build
ifdef skip-user
    @./bin/${BINARY_HTTP}/main -skip-user
else
    @./bin/${BINARY_HTTP}/main
endif

wee:
    @echo "test"
    @go test -count=1 ./test

Tenho dois clones locais do mesmo repositório remoto ( urlA):

1. espelho/ – criado com

   git clone --mirror urlA mirror
   

2. dirB/ – criado com

   git clone --reference-if-able ../mirror urlA dirB
   

No dirB , quando executo:

git fetch
git push

será espelhado/ atualizado por qualquer um dos comandos?

Pelo que entendi, isso --reference-if-ableapenas acelera os downloads de objetos reutilizando objetos do repositório de referência, e não transforma a referência em um controle remoto real que recebe fetchou push. No entanto, encontrei em outro lugar um comentário sugerindo que isso poderia propagar comandos.

Pergunta:
Alguma vez houve --reference[-if-able]um gatilho fetchou pushno repositório de referência? Se não, como posso configurar o Git para que um único git pushcomando ou git fetchde dirB também atualize meu clone do espelho local?

aqui está a execução do meu javascript:

ee_btn.addEventListener('click', () => {
        //Ajax GET request to get data form and rendering it
        RequestEEFormData(container, bounds).then(()=>{
            // Loading a javascript file. it get loaded.
            // I can call function from this file then.
            loadScript('/static/js/locationConverterWidget.js');
        });
        
    });

function loadScript(url) {
    const script = document.createElement('script');
    script.src = url;
    script.async=false;
    script.onload = function(){
        //trying to querySelector newly added content
        console.log(document.querySelector('#id_item);
    }
    document.head.appendChild(script);
  }

em caso:

async function RequestEEFormData(container, bounds) {
    $.ajax({
        type: 'GET',
        url: 'someURL/',

        success: function (response) {
           container.innerHTML=response;
           someFunction(bounds)
        },
        error: function(response){
          console.log(response);
        },
        cache:false,
        contentType: "application/json",
        processData: false
     });
}

o console.log retorna um Nodelist vazio.

Se eu chamar o mesmo consol.log de um botão 1 segundo depois, funciona.

Claramente há algo com o async que não entendo.

Alguém pode me explicar o que estou fazendo errado?

o objetivo é que eu queira que o arquivo javascript recém-baixado consulte o conteúdo recém-adicionado do querySelector, mas ele parece ser executado antes que o HTML seja completamente renderizado.

obrigado

Depois de executar este programa

std::future<int> f() {
    std::cout << "enter f on thread " << std::this_thread::get_id() << std::endl;
    co_return 1;
}
std::future<void> g() {
    std::future<int> i = co_await std::async(f);
    std::cout << "resume g on thread: " << std::this_thread::get_id() << std::endl;
    co_return;
}
int main() {
    std::future<void> f;
    while (true) {
        f = g();
        std::this_thread::sleep_for(1s);
    }
    return 0;
}

que foi compilado com MSVC 19.43 usando a /awaitopção, observei que a função festá sempre sendo executada na mesma thread, enquanto a continuação na função gé sempre executada em uma thread recém-criada. Também tentei chamar std::asynccom std::launch::asynca opção para forçar a criação de uma nova thread, mas ainda assim a mesma thread seria usada para executar f. Alguém pode explicar o porquê?

Por exemplo, considere esta função, que poderia ser usada em um WM para permitir mover uma janela de uma área de trabalho para outra em uma determinada tela,

moveWindowSTM :: Display -> Window -> Desktop -> Desktop -> STM ()
moveWindowSTM disp win a b = do
  wa <- readTVar ma
  wb <- readTVar mb
  writeTVar ma (Set.delete win wa)
  writeTVar mb (Set.insert win wb)
 where
  ma = disp ! a
  mb = disp ! b

e obviamente seu IOinvólucro,

moveWindow :: Display -> Window -> Desktop -> Desktop -> IO ()
moveWindow disp win a b = atomically $ moveWindowSTM disp win a b

e então assumir que

• nossa transação é bem-sucedida na terceira tentativa,
• porque na primeira tentativa ele é invalidado por outra transação simultânea sendo confirmada que altera o valor interno malogo após o término wa <- readTVar mada nossa transação,
• e na segunda tentativa ele é invalidado por outra transação simultânea que altera o conteúdo de uma ou ambas as transações mae mblogo depois writeTVar ma (Set.delete win wa)da nossa transação.

Como o log de transações evoluiria nesse caso e em que ponto a validação falharia?

O trecho relevante de Parallel and Concurrent Programming in Haskell de Simon Marlow está abaixo (mas informações semelhantes estão disponíveis no artigo Beautiful concurrency de Simon Peyton Jones):

Uma transação STM funciona acumulando um log de readTVaroperações writeTVarque ocorreram até o momento durante a transação. O log é usado de três maneiras:

• Ao armazenar writeTVaras operações no log em vez de aplicá-las imediatamente à memória principal, descartar os efeitos de uma transação é fácil; simplesmente descartamos o log. Portanto, abortar uma transação tem um custo fixo pequeno.

• Cada um readTVardeve percorrer o log para verificar se o TVarfoi escrito por um writeTVar. Portanto, readTVaré uma operação O(n) no comprimento do log.

• Como o log contém um registro de todas as readTVaroperações, ele pode ser usado para descobrir o conjunto completo de TVarsleituras durante a transação, o que precisamos saber para implementar retry.

Quando uma transação chega ao fim, a implementação do STM compara o log com o conteúdo da memória. Se o conteúdo atual da memória corresponder aos valores lidos por readTVar, os efeitos da transação são confirmados na memória; caso contrário, o log é descartado e a transação é executada novamente desde o início. Esse processo ocorre atomicamente, bloqueando todos os TVarsenvolvidos na transação durante sua duração. A implementação do STM no GHC não utiliza bloqueios globais; apenas os TVarsenvolvidos na transação são bloqueados durante o commit, de modo que transações que operam em conjuntos disjuntos de TVarspodem prosseguir sem interferência.

Estou com problemas para criar novas entidades com relacionamentos um-para-um. O EF Core não está atribuindo as chaves estrangeiras corretamente.

Como exemplo, vamos pegar duas entidades:

public class User
{
    public int Id { get; set; }
    public int BlogId { get; set; }
    public Blog Blog { get; set; }
}

public class Blog
{
    public int Id { get; set; }
    public int UserId { get; set; }
    public User User { get; set; }
}

Defina o relacionamento deles de modo que fique claro qual depende de qual:

protected override void OnModelCreating(ModelBuilder builder)
{
    builder.Entity<User>()
        .HasOne(u => u.Blog)
        .WithOne(b => b.User)
        .HasForeignKey<Blog>()
        .IsRequired();
}

Então, quando tento criá-los assim:

var user = new User 
               {
                   Blog = new Blog(),
               };

await DbContext.Set<User>().AddAsync(user);
await DbContext.SaveChangesAsync();

O Blogfoi criado e sua UserIdpropriedade está definida corretamente. No entanto, a BlogIdpropriedade de Useré 0. De acordo com a documentação , deve ser possível criar entidades relacionadas como esta.

Isso não se aplica a relacionamentos individuais? Ou há algo mais que não estou percebendo?

A propósito, estou usando o PostgreSQL, caso o provedor do banco de dados tenha algo a ver com isso. Também estou usando o EF Core versão 9.

Atualmente, estou trabalhando em um gerador de jogadas de xadrez voltado para desempenho e usando muitas declarações de classes enum fortemente tipadas para funções como Quadrado, Arquivo, Classificação, Cor, Tipo de Peça, Roque, Direção, etc. Enfrentei o problema de precisar converter constantemente valores de classes enum para o tipo subjacente (uint8_t) e vice-versa para usá-los como índices de array, realizar operações aritméticas, passá-los como argumentos ou combiná-los em lógica. Isso resulta em toneladas de static_cast<uint8_t>(...) repetitivos e feios por todo o código, como no seguinte MRE:

#include <array>
#include <cstdint>
#include <cstdlib>
#include <iostream>

using u8 = uint8_t;
using Bitboard = uint64_t;

enum class File : u8 {
    FA, FB, FC, FD, FE, FF, FG, FH, NB
};

enum class Rank : u8 {
    R1, R2, R3, R4, R5, R6, R7, R8, NB
};

enum class Square : u8 {
    A1, B1, C1, D1, E1, F1, G1, H1,
    A2, B2, C2, D2, E2, F2, G2, H2,
    A3, B3, C3, D3, E3, F3, G3, H3,
    A4, B4, C4, D4, E4, F4, G4, H4,
    A5, B5, C5, D5, E5, F5, G5, H5,
    A6, B6, C6, D6, E6, F6, G6, H6,
    A7, B7, C7, D7, E7, F7, G7, H7,
    A8, B8, C8, D8, E8, F8, G8, H8,
    NB, FIRST = A1, LAST = H8
};

enum class Color : u8 { WHITE, BLACK, NB };
enum class PieceType : u8 { PAWN, KNIGHT, BISHOP, ROOK, QUEEN, KING, NB };

constexpr File getFile(Square sq) {
    return static_cast<File>(static_cast<u8>(sq) % 8);
}

constexpr Rank getRank(Square sq) {
    return static_cast<Rank>(static_cast<u8>(sq) / 8);
}

std::array<std::array<u8, static_cast<u8>(Square::NB)>, static_cast<u8>(Square::NB)> squareDistance{};
std::array<std::array<Bitboard, static_cast<u8>(Square::NB)>, static_cast<u8>(Color::NB)> pawnAttacks{};
std::array<std::array<Bitboard, static_cast<u8>(Square::NB)>, static_cast<u8>(PieceType::NB)> pseudoAttacks{};

void precomputeSquareDistance() {
    for (u8 s1 = static_cast<u8>(Square::FIRST); s1 <= static_cast<u8>(Square::LAST); ++s1) {
        for (u8 s2 = static_cast<u8>(Square::FIRST); s2 <= static_cast<u8>(Square::LAST); ++s2) {
            squareDistance[s1][s2] =
                std::abs(static_cast<int>(getFile(static_cast<Square>(s1))) - static_cast<int>(getFile(static_cast<Square>(s2)))) +
                std::abs(static_cast<int>(getRank(static_cast<Square>(s1))) - static_cast<int>(getRank(static_cast<Square>(s2))));
        }
    }
}

int main() {
    precomputeSquareDistance();
    std::cout << static_cast<int>(squareDistance[static_cast<u8>(Square::A1)][static_cast<u8>(Square::H8)]) << "\n";
    return 0;
}

Escolhi a classe enum de propósito porque tenho muitas enumerações em todo o meu código-fonte. Também prefiro unsigned char em vez de int, pois melhora o desempenho.

No entanto, minhas decisões vêm ao custo de verbosidade e código excessivamente confuso.

Tentei resolver o problema com uma macro para habilitar operadores "compatíveis com u8" (por exemplo, sobrecargas para +, -, ++, comparações, etc.) para tipos de classes enum gerais. Dessa forma, eu poderia evitar escrever todas essas conversões. Mas isso rapidamente se transformou em um milhão de combinações possíveis de tipos enum e uint8_t, além da necessidade de modelos ou metaprogramação de macros, e simplesmente parecia errado e insustentável. Além disso, não resolveu o problema de acessar o array diretamente.

Existe uma maneira limpa, segura e não insana de trabalhar com valores de classe enum como inteiros sem usar static_cast?

O que desenvolvedores experientes em C++ fazem nesses casos? Estou esquecendo de algum padrão de design simples?

Desde já, obrigado.

<!DOCTYPE html>
<html>
    <head>
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <title>
            What's Up At Pearson?
        </title>
        <style>
        
            
            
            .dropbtn {
            font-family: Monospace;
            font-size: 50px;
            margin-top: 5px;
            margin-bottom: 5px;
            border-color: black;
            }
            
            .dropdown {
            position: relative;
            display: inline-block;
            }
           
            
            .dropdown-content {
            display: none;
            position: relative;
            background-color: #f5e162;
            min-width: 160px;
            box-shadow: 0px 8px 16px 0px rgba(0,0,0,0.2);
            z-index: 1;
            
            }
            
            .dropdown-content a {
            color: white;
            padding: 12px 16px;
            text-decoration: none;
            display: block;
            
            }
            
            hr{
            border-color:#ff5c4a;
            
            }
            
            .dropdown-content a:hover {background-color: #f25757;}
            
            .dropdown:hover .dropdown-content {display: block;}
            
            .dropdown:hover .dropbtn {background-color: #ddd;}
        </style>
    </head>
    <body>
        <h1 style = "background-color: red; color: white; font-family: Monospace; font-size: 38px;
        margin: 0; padding: 10px">
            What's Up At Pearson?
            <img align = "right"width = "50px" height = "50px" 
            src = "https://upload.wikimedia.org/wikipedia/en/8/89/Lester_B_Pearson_High_School_Calgary_new_logo.png">
        </h1>
        
        <br>
        <hr style = "border-top: 5px solid yellow">
        
        <p style = "text-align: center; font-size:20px; font-family: Monospace">
            Welcome to the website What's Up At Pearson? A semi-interactive place full of interviews
            from your fellow students. Have some insight into different struggles students in 
            different subject areas may have while also learning some tips they may have that could
            help you. (This is a new computer science project, sorry if website looks bad :[)
        </p>
        
        <h2 style = "text-align: center; font-size: 30px; font-family: Monospace">
            Different Subject Areas Listed Below
        </h2>
        <hr>
        <div class = " dropdown">
            <button class = "dropbtn">Math</button>
            <div class = "dropdown-content">
                <a href = ""> Math</a>
            </div>
        </div>
        <hr>
        <div class = " dropdown">
            <button class = "dropbtn"> Sciences</button>
            <div class = "dropdown-content">
                <a href = ""> Physics</a>
                <a href = ""> Chemistry</a>
                <a href = ""> Bio</a>
            </div>
        </div>
        <hr>
        <div class = " dropdown">
            <button class = "dropbtn">Social Studies</button>
            <div class = "dropdown-content">
                <a href = "">Social Studies</a>
            </div>
        </div>
        <hr>
        <div class = " dropdown">
            <button class = "dropbtn">English</button>
            <div class = "dropdown-content">
                <a href = "">English</a>
            </div>
        </div>
        <hr>
        <div class = " dropdown">
            <button class = "dropbtn">CTS</button>
            <div class = "dropdown-content">
                <a href = "">Animation</a>
                <a href = "">Architecture</a>
                <a href = "">Computer Science</a>
                <a href = "">Construction</a>
                <a href = "">Pre-Engineering</a>
            </div>
        </div>
        <hr>
        <div class = " dropdown">
            <button class = "dropbtn">Fine Arts</button>
            <div class = "dropdown-content">
                <a href = "">Art</a>
                <a href = "">Dance</a>
                <a href = "">Drama</a>
                <a href = "">Technical Theatre</a>
                <a href = "">Culinary</a>
            </div>
        </div>
        <hr>
        <div class = "dropdown">
            <button class = "dropbtn">Personal</button>
            <div class = "dropdown-content">
                <a href = "">Buissness Managment</a>
                <a href = "">Gym</a>
                <a href = "">Yoga</a>
            </div>
        </div>
        <hr>
        
    </body>
</html>

Acima está o CSS que criei para os botões do menu suspenso em HTML. Como eu os alinharia ao centro da tela? Tentei o text-align, mas não funcionou. Uma solução que tentei antes fazia o menu aparecer na lateral do botão, em vez de na parte inferior. Existe algum código que o alinhe ao centro e ainda funcione corretamente como um menu?