All perguntas(coding)

Tentei implementar a navegação React, mas encontrei muitos erros, embora meus códigos sejam bem estruturados de acordo com os padrões de navegação. Não sei qual(is) poderia(m) ser o(s) erro(s) que me impediu(aram) de navegar pelos componentes.

Estou usando o React Native puro, não com o Expo

Eu esperava poder navegar de outro componente sem esses problemas. Espero que alguém resolva esse problema. Obrigado.

Aplicativo.js

import { StatusBar } from 'expo-status-bar';
import { StyleSheet, Text, View } from 'react-native';
import * as React from 'react';
import { NavigationContainer } from '@react-navigation/native';
import AppNavigator from './components/AppNavigator';
import {StorageCon} from './components/StorageCon';

export default function App() {
  return (
    <NavigationContainer>
   
      <AppNavigator/>
   
    </NavigationContainer>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    backgroundColor: '#fff',
    alignItems: 'center',
    justifyContent: 'center',
  },
});

AppNavigator.js

import { createStackNavigator } from "@react-navigation/stack";
import TitlescreenPage from "./TitlescreenPage";

const Stack = createStackNavigator();

const AppNavigator=()=>{

    return(
        <>
        <Stack.Navigator>
            <Stack.Screen name = "titlescreen" component={TitlescreenPage} />
        </Stack.Navigator>

        </>
    );
};

export default AppNavigator;

insira a descrição da imagem aqui insira a descrição da imagem aqui

Aqui está o meu problema: tenho um bloco de código local como o abaixo. Preciso criar um mapa a partir desses valores (eles são usados ​​em vários lugares).

locals {
  object = {
    1 = {
      name = "val1"
      keys = ["val1"]
    }
    2 = {
      name = "val2"
      keys = ["val2", "val3", "val4"]
    }
  }
  associations = flatten(
    [
      for obj in local.object : [
        for association_key in obj.keys : {
          "${obj.name}-${association_key}" = {
            key             = obj.name
            association_key = association_key
          }
        }
      ]
    ]
  )
}

Quando executo um plano do Terraform gerando o resultado acima, obtenho:

testing = [
      + {
          + val1-val1 = {
              + association_key = "val1"
              + key             = "val1"
            }
        },
      + {
          + val2-val2 = {
              + association_key = "val2"
              + key             = "val2"
            }
        },
      + {
          + val2-val3 = {
              + association_key = "val3"
              + key             = "val2"
            }
        },
      + {
          + val2-val4 = {
              + association_key = "val4"
              + key             = "val2"
            }
        },
    ]

O que preciso obter, no entanto, é algo como isto:

testing = [
          + val1-val1 = {
              + association_key = "val1"
              + key             = "val1"
            }
          + val2-val2 = {
              + association_key = "val2"
              + key             = "val2"
            }
          + val2-val3 = {
              + association_key = "val3"
              + key             = "val2"
            }
          + val2-val4 = {
              + association_key = "val4"
              + key             = "val2"
            }
    ]

O motivo para isso é que há muitas repetições no valor das chaves do objeto e é necessário que haja um valor exclusivo no mapa.

Tentei a solução Aqui , mas não consegui criar o mapa que preciso.

Estou quebrando a cabeça com essa pergunta, provavelmente bem simples, e não consigo encontrar a resposta em lugar nenhum. Quero criar uma nova coluna com a soma agrupada de outra coluna, mas quero manter todas as linhas individuais. Então, aqui está o que a documentação diz:

import polars as pl

df = pl.DataFrame(
    {
        "a": ["a", "b", "a", "b", "c"],
        "b": [1, 2, 1, 3, 3],
    }
)

df.group_by("a").agg(pl.col("b").sum())  

O resultado disso seria:

shape: (3, 2)
┌─────┬─────┐
│ a   ┆ b   │
│ --- ┆ --- │
│ str ┆ i64 │
╞═════╪═════╡
│ a   ┆ 2   │
│ c   ┆ 3   │
│ b   ┆ 5   │
└─────┴─────┘

No entanto, o que eu preciso é disto:

shape: (5, 3)
┌─────┬─────┬────────┐
│ a   ┆ b   ┆ sum(b) │
│ --- ┆ --- ┆ ------ │
│ str ┆ i64 ┆ i64    │
╞═════╪═════╪════════╡
│ a   ┆ 1   ┆ 2      │
│ b   ┆ 2   ┆ 5      │
│ a   ┆ 1   ┆ 2      │
│ b   ┆ 3   ┆ 5      │
│ c   ┆ 3   ┆ 3      │
└─────┴─────┴────────┘

Eu poderia criar a soma em um df separado e depois uni-la ao original, mas tenho certeza de que há uma solução mais fácil.

Estou usando python3.12 no sistema operacional Ubuntu Linux quando faço:

import pyautogui as p
p.click(x, y)

Não clica de jeito nenhum, as outras funções como pyautogui.scroll, .positione todas funcionam corretamente, mas não clicam.

Tenho um Playbook de controle que busca dados de grupo de uma API durante o tempo de execução. Com base nesses grupos, quero adicionar Plays dinamicamente à execução (com Hosts e Vars diferentes).

Pelo que entendi, era para isso que servia o módulo "include". No entanto, a documentação diz que ele está obsoleto. Então, agora me pergunto: qual é uma maneira à prova de futuro de adicionar Plays dinamicamente em tempo de execução?

"include_tasks" não resolverá o problema, pois as tarefas incluídas pertencerão ao mesmo Play e, portanto, usarão os mesmos Hosts.

Gostaria de obter o nome, sobrenome e a contagem de jogadores visualizados presentes na coluna Viewed_PlayerIDda tabela ViewedPlayers de cada usuário, cujo ID de usuário está presente na coluna CreatedByCharacterIDda tabela ViewedPlayers. Dos quais o que viewed_playerIDestá marcado como "jogador de equipe" na coluna UserTypeda tabela Users.

Mesa Users:

Mesa ViewedPlayers:

Resultado esperado:

Eu tentei 2 consultas diferentes

Consulta nº 1:

SELECT      
    c.Firstname, c.LastName,
    SUM(CASE WHEN p.CreatedByCharacterID THEN 1 ELSE 0 END) AS Count
FROM 
    Users c
JOIN    
    ViewedPlayers p ON p.CreatedByCharacterID = c.ID
WHERE   
    c.UserType = 'Teamplayer'
GROUP BY 
    p.CreatedByCharacterID
ORDER BY 
    SUM(CASE WHEN p.CreatedByCharacterID THEN 1 ELSE 0 END) DESC

Consulta nº 2:

SELECT      
    c.Firstname, c.LastName,
    SUM(CASE WHEN c. UserType = 'Teamplayer' AND p.CreatedByCharacterID THEN 1 ELSE 0 END) AS Count
FROM    
    Users c
JOIN
    ViewedPlayers p ON p.CreatedByCharacterID = c.ID
GROUP BY 
    p.CreatedByCharacterID
ORDER BY 
    SUM(CASE WHEN p.CreatedByCharacterID THEN 1 ELSE 0 END) DESC

Criei um programa que converte uma planilha do Excel contendo a agenda dos meus departamentos em uma tabela SQL. Sempre trabalhamos em duplas, então quero poder verificar todos os meus turnos e com qual pessoa trabalharei nesses turnos.
A estrutura da tabela é: onde T, K e N são os diferentes turnos:

Se eu fosse Jim na tabela acima, gostaria de obter uma resposta para 2025-04-14 como:

E para 2025-04-15 como:

Sinceramente, não tenho a mínima ideia de como fazer algo assim. Só fiz consultas SQL bem básicas antes, como encontrar todas as linhas em que X é igual a Y.

Meu objetivo é serializar informações usando protobuf em C++.

arquivo proto:

syntax = "proto3";

package PhoneBookSerialize;

message Date {
  int32 year = 1;
  int32 month = 2;
  int32 day = 3;
}

message Contact {
  string name = 1;
  Date birthday = 2;
  repeated string phone_number = 3;
}


message ContactList{
  repeated Contact contact = 1;
}

Código relacionado ao contato:

struct Contact {
  std::string name;
  std::optional<Date> birthday;
  std::vector<std::string> phones;

  bool operator<(const Contact& other) const {
    return name < other.name;
  }
};

class PhoneBook {
public:
  
  explicit PhoneBook(std::vector<Contact> contacts);
  void SaveTo(std::ostream& output) const;

private:
  std::vector<Contact> contact_book;

};

PhoneBook::PhoneBook(std::vector<Contact> contacts) : contact_book(contacts) {
    std::sort(contact_book.begin(), contact_book.end());
};

Função de serialização:

void PhoneBook::SaveTo(std::ostream& output) const {
    PhoneBookSerialize::ContactList contact_list;
    for(const auto& contact : contact_book){
        PhoneBookSerialize::Contact* pb_contact = contact_list.add_contact();
        pb_contact->set_name(contact.name);
        if(contact.birthday.has_value()){
            PhoneBookSerialize::Date* pb_date = pb_contact->mutable_birthday();
            pb_date->set_year(contact.birthday->year);
            pb_date->set_month(contact.birthday->month);
            pb_date->set_day(contact.birthday->day);
        }
        
        for(const auto& phone : contact.phones){
            pb_contact->add_phone_number(phone);
        }
    }

    contact_list.SerializeToOstream(&output);
};

arquivo main.cpp

#include "phone_book.h"
#include "contact.pb.h"
#include <sstream>

using namespace std;

int main(){
    const PhoneBook ab({
        {"Ab ba", Date{1980, 1, 13}, {"+79850685521"}},
        {"Ac ca", Date{1989, 4, 23}, {"+79998887766", "+71112223344"}},
        {"Ad da", Date{1989, 4, 23}, {}},
        {"No Birthday", std::nullopt, {"+7-4862-77-25-64"}},
      });
    
      ostringstream output(std::ios::binary);
      ab.SaveTo(output);
    
      istringstream input(output.str(), std::ios::binary);
    
      PhoneBookSerialize::ContactList list;
      list.ParseFromIstream(&input);
      return 0;
}

Arquivo CMakeLists.txt:

cmake_minimum_required(VERSION 3.10)
project(PhoneBookProtobuf LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# Find Protocol Buffers package
find_package(Protobuf REQUIRED)

# Find Abseil package
find_package(absl REQUIRED)

include_directories(${Protobuf_INCLUDE_DIRS})
include_directories(${CMAKE_CURRENT_BINARY_DIR})

# Generate protobuf files from proto directory
protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS proto/contact.proto)

# Add all source files
add_executable(main
    src/main.cpp
    src/phone_book.cpp
    src/phone_book.h
    ${PROTO_SRCS}
    ${PROTO_HDRS}
)

# Link necessary libraries
target_link_libraries(main 
    ${Protobuf_LIBRARIES}
    absl::log
    absl::log_internal_message
    absl::log_internal_check_op
)

Estou usando os seguintes comandos para criar e executar meu código:

1. Configure project:
cmake --preset default

2. Build Project:
cmake --build --preset debug

3. Run Project:
./build/main

Depois de executar o projeto, estou recebendo uma falha de segmentação no list.ParseFromIstream(&input);. Suponho que tenha algo a ver com o meu arquivo de configuração do Cmake. Também adicionei o pacote abseil à minha configuração do Cmake, porque sem ele no meu sistema operacional (macOS), o código não compila.

Mensagens de erro:

AddressSanitizer:DEADLYSIGNAL
=================================================================
==4319==ERROR: AddressSanitizer: SEGV on unknown address 0x000000000020 (pc 0x000000000020 bp 0x7ff7b0d5f350 sp 0x7ff7b0d5f318 T0)
==4319==Hint: pc points to the zero page.
==4319==The signal is caused by a READ memory access.
==4319==Hint: address points to the zero page.
    #0 0x000000000020  (<unknown module>)
    #1 0x00010f5e6a24 in google::protobuf::internal::TcParser::FastMtR1(google::protobuf::MessageLite*, char const*, google::protobuf::internal::ParseContext*, google::protobuf::internal::TcFieldData, google::protobuf::internal::TcParseTableBase const*, unsigned long long)+0x74 (libprotobuf.29.3.0.dylib:x86_64+0xb8a24)
    #2 0x00010f63abdb in bool google::protobuf::internal::MergeFromImpl<false>(google::protobuf::io::ZeroCopyInputStream*, google::protobuf::MessageLite*, google::protobuf::internal::TcParseTableBase const*, google::protobuf::MessageLite::ParseFlags)+0xd1 (libprotobuf.29.3.0.dylib:x86_64+0x10cbdb)
    #3 0x00010f63bda2 in google::protobuf::MessageLite::ParseFromIstream(std::__1::basic_istream<char, std::__1::char_traits<char>>*)+0x32 (libprotobuf.29.3.0.dylib:x86_64+0x10dda2)
    #4 0x00010f1adbf9 in main main.cpp:23
    #5 0x7ff8165ad52f in start+0xbef (dyld:x86_64+0xfffffffffff1f52f)

==4319==Register values:
rax = 0x0000606000001700  rbx = 0x00007ff7b0d5fb20  rcx = 0x0000000000000020  rdx = 0x0000000000000000  
rdi = 0x000000010f220840  rsi = 0x0000606000001700  rbp = 0x00007ff7b0d5f350  rsp = 0x00007ff7b0d5f318  
 r8 = 0xffffffffffffffff   r9 = 0x0000000000000000  r10 = 0x00007fffffffff01  r11 = 0x00007fffffffff01  
r12 = 0x000000010f222480  r13 = 0x00007ff7b0d5f3e8  r14 = 0x0000000000000000  r15 = 0x0000000000000000  
AddressSanitizer can not provide additional info.
SUMMARY: AddressSanitizer: SEGV (<unknown module>) 
==4319==ABORTING
zsh: abort      ./build/main

Estou tentando contar rapidamente uma competição em que os times jogam entre si no máximo 2 vezes.

Esta é uma pequena amostra, pois tenho cerca de 600 linhas para analisar. Consultei Countifs e Match, mas não consigo encontrar a fórmula certa.

O ideal é localizar e executar um "ping" em um número de resultado se duas colunas corresponderem, mesmo que não estejam nas mesmas colunas que as anteriores (por exemplo, a linha 2 e a linha 5 seriam uma correspondência).

Estou trabalhando em um projeto Flutter e usando o pacote frozen. Criei uma classe ApiResult genérica como esta:

import 'package:freezed_annotation/freezed_annotation.dart';

part 'api_result.freezed.dart';

@freezed
sealed class ApiResult<T> with _$ApiResult<T> {
  const factory ApiResult.success(T data) = Success<T>;
  const factory ApiResult.failure(String msg) = Failure<T>;
}

Após executar a geração de código, o arquivo gerado não inclui when, map ou métodos semelhantes de correspondência de padrões. Aqui está um trecho do código gerado:

class Success<T> implements ApiResult<T> {
  const Success(this.data);
  final T data;
  // ...
}

class Failure<T> implements ApiResult<T> {
  const Failure(this.msg);
  final String msg;
  // ...
}

Como você pode ver, não há métodos when ou map gerados. Eu esperava que eles estivessem disponíveis, já que são comumente usados ​​com classes congeladas para correspondência de padrões.

Por que os métodos when e map estão faltando? Como posso corrigir isso?

Estou usando a versão mais recente do frozen e build_runner e executei

dart run build_runner build --delete-conflicting-outputs 

sem problemas. Qualquer ajuda será bem-vinda!