All perguntas(coding)

Eu tenho o seguinte código:

drop table if exists statusCodes;

create table statusCodes (statusCode UInt16) engine=Memory;

insert into statusCodes values (0);
insert into statusCodes values (200);
insert into statusCodes values (200);
insert into statusCodes values (200);
insert into statusCodes values (200);
insert into statusCodes values (200);
insert into statusCodes values (201);
insert into statusCodes values (301);
insert into statusCodes values (301);
insert into statusCodes values (301);
insert into statusCodes values (301);
insert into statusCodes values (304);
insert into statusCodes values (404);
insert into statusCodes values (500);

select
    multiIf(statusCode >= 500, '5xx', statusCode >= 400, '4xx', statusCode >= 300, '3xx', statusCode >= 200, '2xx', 'errored'),
    groupArray(statusCode),
    count(1) as count
from statusCodes
group by 1;

violino aqui: https://fiddle.clickhouse.com/b3b3dfb9-1826-47a8-b201-831498c941f2

Isso me dá

Mas eu quero ter algo como

Então, para resumir , quero agrupar todos os códigos de status por categoria principal (2xx, 3xx, 4xx, 5xx) e em linha, outro agrupamento por código de status real desta categoria.

Preciso escrever um programa que encontre com eficiência o comprimento da maior sequência contínua de zeros em um determinado segmento [l, r](uma submatriz específica) e atualize o valor, se solicitado, ambas as operações em tempo logarítmico.

Eu tenho este código:

import java.io.*;
import java.util.Objects;
import java.util.StringTokenizer;

public class task {
    static class treeLeaf {
        int maxSeq;
        int prefSeq;
        int suffSeq;
        int length;

        treeLeaf(int maxSeq, int prefSeq, int suffSeq, int length) {
            this.maxSeq = maxSeq;
            this.prefSeq = prefSeq;
            this.suffSeq = suffSeq;
            this.length = length;
        }
    }

    static treeLeaf merge(treeLeaf left, treeLeaf right) {
        int maxSeq = Math.max(left.maxSeq, right.maxSeq);
        if (left.suffSeq > 0 && right.prefSeq > 0) {
            maxSeq = Math.max(maxSeq, left.suffSeq + right.prefSeq);
        }

        int prefSeq = left.prefSeq;
        if (left.prefSeq == left.length) {
            prefSeq += right.prefSeq;
        }

        int suffSeq = right.suffSeq;
        if (right.suffSeq == right.length) {
            suffSeq += left.suffSeq;
        }

        return new treeLeaf(maxSeq, prefSeq, suffSeq, left.length + right.length);
    }

    static treeLeaf rmq(int l, int r, treeLeaf[] tree) {
        int n = tree.length / 2;
        l += n;
        r += n;
        treeLeaf res = new treeLeaf(0, 0, 0, 0);

        while (l <= r) {
            if ((l & 1) == 1) {
                res = merge(res, tree[l]);
                l++;
            }
            if ((r & 1) == 0) {
                res = merge(res, tree[r]);
                r--;
            }
            if (l > r) break;
            l /= 2;
            r /= 2;
        }
        return res;
    }
}

Mas quando executo o teste:

18
6 0 0 1 0 0 0 0 2 4 5 6 9 0 0 0 0 1
1
QUERY 1 18

Meu programa imprime 5em vez de 4. Suspeito que o problema seja com function merge, mas não vejo isso ...

Eu estava experimentando algumas coisas com o Span<T>tipo. Meu objetivo era fazer um método de extensão para enumerar a divisão de a ReadOnlySpan<char>, para ser usado da seguinte forma:

var x = "foo,bar,baz".AsSpan();
var options = StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries;

foreach (var word in x.EnumerateSplit(',', options))
{
    // Should enumerate foo, bar and baz
}

Mas quando eu implemento meu próprio tipo de enumerador que encapsula uma Span<Range>.Enumeratorinstância nos bastidores, um IndexOutOfRangeExceptioné lançado ao acessar a Currentpropriedade do enumerador encapsulado.

Tentei criar o enumerador mais básico que tivesse apenas uma lógica de encapsulamento sem mecânica de divisão:

public ref struct BasicEnumerator
{
    // Encapsulated enumerator
    private readonly Span<Range>.Enumerator _enumerator;

    public Range Current => _enumerator.Current;

    public BasicEnumerator(Span<Range>.Enumerator enumerator)
    {
        _enumerator = enumerator;
    }

    public bool MoveNext() => _enumerator.MoveNext();

    // Called by foreach
    public BasicEnumerator GetEnumerator() => this;
}

Com esse BasicEnumeratortipo, eu esperava pelo menos que esse trecho de código funcionasse:

Span<Range> test = stackalloc Range[5];
var enumerator = new BasicEnumerator(test.GetEnumerator());

foreach (Range r in enumerator)
{
    Console.WriteLine(r);
}

Mas an IndexOutOfRangeExceptioné lançado na primeira iteração.

Eu também tentei mais simples sem usar foreach:

Span<Range> test = stackalloc Range[5];
var enumerator = new BasicEnumerator(test.GetEnumerator());

if (enumerator.MoveNext())
{
    Console.WriteLine(enumerator.Current);
}

O IndexOutOfRangeExceptionainda é lançado ao tentar acessar o arquivo enumerator.Current.

Observe que quando eu uso o Span<Range>.Enumeratorem vez disso (da mesma maneira), funciona:

Span<Range> test = stackalloc Range[5];
Span<Range>.Enumerator enumerator = test.GetEnumerator();

if (enumerator.MoveNext())
{
    Console.WriteLine(enumerator.Current);
}

Durante a depuração, descobri que não está funcionando porque o Span<Range>.Enumerator.MoveNextmétodo não aumenta o índice subjacente, mas ainda retorna true: Captura de tela de depuração do Visual Studio

Eu realmente não sei por que está fazendo isso. Eu diria que é um problema de referência, mas não sei por que e como resolvê-lo. Tentei encontrar documentação sobre um caso de uso semelhante, sem sucesso.

Estou usando o .NET 8.

Eu quero armazenar este quadro de dados

df = pd.DataFrame({
            'id':[1,1,2,2], 
            'gender':["m","m","f","f"], 
            'val1':[1,2,5,6], 
            'val2':[3,4,7,8]
}).set_index(['id','gender'])

como um arquivo json que contém listas de dicionários como este:

d = [{'id':1, 'gender':"m", 'val1':[1,2], 'val2':[3,4]},
     {'id':2, 'gender':"f", 'val1':[5,6], 'val2':[7,8]}]

Todas as minhas tentativas de usar variações df.to_dict(orient = '...')ou df.to_json(orient = '...')não produziram o resultado desejado.

Eu tenho uma macro que cria uma instância de uma classe Infoque aceita arrays com tamanho modelado como argumentos do construtor. As informações de tamanho são usadas para verificações.

Gostaria de fazer uma verificação nesta macro antes de retornar a instância. O cheque pode ser algo como static_assert, mas vamos deixar isso aberto aqui. Uma maneira elegante de fazer a verificação é fazer com que a macro chame um lambda que execute a(s) verificação(ões) e depois retorne a instância.

Mas isso falha por um motivo muito chato: se eu passar arrays char para um autoargumento do lambda, eles serão deduzidos como charponteiros e isso impedirá a chamada do Infoconstrutor. Então, eu gostaria de passar matrizes de caracteres com tamanho modelado para o lambda. Mas isso só é possível a partir do C++20.

Existe alguma solução alternativa? Posso fazer um lambda aceitar matrizes de tamanho modelado com C++ 17?

Código:

#include <cstdlib>
#include <iostream>

class Info
{
  public:
    template <size_t function_length, size_t file_length>
    Info(const char (&function)[function_length], const char (&file)[file_length])
        : function(function)
        , file(file)
    {
        if ('\0' != function[function_length - 1])
        {
            this->function = "invalid";
        }

        if ('\0' != file[file_length - 1])
        {
            this->file = "invalid";
        }
    }

    const char* function;
    const char* file;
};

#define CREATE_INFO()                                                                                                  \
    (                                                                                                                  \
        []<std::size_t function_length, std::size_t file_length>(                                                      \
            const auto(&function)[function_length], const auto(&file)[file_length])                                    \
        {                                                                                                              \
            static constexpr char error_string[] = "invalid";                                                          \
                                                                                                                       \
            if ('m' != function[0])                                                                                    \
            {                                                                                                          \
                return Info(error_string, error_string);                                                               \
            }                                                                                                          \
            return Info(function, file);                                                                               \
        }(__FUNCTION__, __FILE__))

int main()
{
    Info info = CREATE_INFO();

    std::cout << "Function: " << info.function << ", file: " << info.file << std::endl;

    return 0;
}

Exemplo no Compiler Explorer: https://godbolt.org/z/8q5zYKj4a

Estou trabalhando com transcrições de fala:

  Utterance                       Starttime_ms Endtime_ms
  <chr>                                  <dbl>      <dbl>
1 on this                                  210        780
2 okay                                    3403       3728
3 cool thanks everyone um                 4221       5880
4 so yes in terms of our projects         5910      11960
5 let's have a look so the               11980      13740
6 LGBTQ plus                             13813      16110

e gostaria de inserir após cada Utteranceuma nova linha indicando o intervalo de tempo em relação ao anterior Utterance. A saída desejada seria mais ou menos assim:

  Utterance                       Starttime_ms Endtime_ms
  <chr>                                  <dbl>      <dbl>
1 on this                                  210        780
  NA                                       780       3403
2 okay                                    3403       3728
  NA                                      3728       4221
3 cool thanks everyone um                 4221       5880
  NA                                      5880       5910
4 so yes in terms of our projects         5910      11960
  NA                                     11960      11980
5 let's have a look so the               11980      13740
  NA                                     13740      13813
6 LGBTQ plus                             13813      16110

Eu sei como fazer isso em data.table:

library(data.table)
unq <- c(0, sort(unique(setDT(df)[, c(Starttime_ms, Endtime_ms)])))
df <- df[.(unq[-length(unq)], unq[-1]), on=c("Starttime_ms", "Endtime_ms")]

Mas estou procurando uma dplyrsolução.

Dados:

df <-   structure(list(Utterance = c("on this", "okay", "cool thanks everyone um", 
                                     "so yes in terms of our projects", 
                                     "let's have a look so the", "LGBTQ plus"), Starttime_ms = c(210, 
                                                                                                 3403, 4221, 5910, 11980, 13813), Endtime_ms = c(780, 3728, 5880, 
                                                                                                                                                 11960, 13740, 16110)), row.names = c(NA, -6L), class = c("tbl_df", 
                                                                                                                                                                                                          "tbl", "data.frame"))

Preparei um caso de teste simples no Github para minha pergunta:

Em RouterLayout.jsx, uma consulta de mídia faz Outletdesaparecer em telas estreitas, como você pode ver na captura de tela animada, onde arrasto a lateral do navegador para torná-la menor:

RootLayout.jsx

import { Outlet } from "react-router";
import { useMediaQuery } from "@react-hook/media-query";
import MasterList from "../components/MasterList";

export default function RootLayout() {
  const isSmallScreen = useMediaQuery("(max-width: 768px)");

  return (
    <div
      style={{
        display: "flex",
        justifyContent: "space-around",
        alignItems: "flex-start",
      }}
    >
      <MasterList />
      {!isSmallScreen && (
        <div>
          <h3>Detail</h3>
          <Outlet />
        </div>
      )}
    </div>
  );
}

Minha pergunta, por favor:

Em telas pequenas de celulares apenas a Lista Mestre deve ser exibida. E quando um Link for clicado ali, uma Página1 ou outras páginas deverão ser exibidas, com possibilidade de retornar à Lista Mestre. Isso ainda não funciona.

Em telas grandes de tablets e computadores, a Lista mestre e a Página1 ou outras são exibidas próximas uma da outra. Isso já funciona no meu código.

Devo adicionar algum atributo ao Links no MasterList.jsx abaixo?

MasterList.jsx

import { Link } from "react-router-dom";

const MasterList = () => {
  const pages = [
    { id: 1, title: "Page 1" },
    { id: 2, title: "Page 2" },
    { id: 3, title: "Page 3" },
    { id: 4, title: "Page 4" },
  ];

  return (
    <div>
      <h2>Master List</h2>
      <nav>
        <ul>
          {pages.map((page) => (
            <li key={page.id}>
              <Link to={"/page" + page.id}>{page.title}</Link>
            </li>
          ))}
        </ul>
      </nav>
    </div>
  );
};

export default MasterList;

Aplicativo.jsx

import {
  Route,
  RouterProvider,
  createBrowserRouter,
  createRoutesFromElements,
} from "react-router-dom";
import Page1 from "./pages/Page1";
import Page2 from "./pages/Page2";
import Page3 from "./pages/Page3";
import Page4 from "./pages/Page4";
import RootLayout from "./layouts/RootLayout";

const router = createBrowserRouter(
  createRoutesFromElements(
    <Route path="/" element={<RootLayout />}>
      <Route path="page1" element={<Page1 />} />
      <Route path="page2" element={<Page2 />} />
      <Route path="page3" element={<Page3 />} />
      <Route path="*" element={<Page4 />} />
    </Route>
  )
);

const App = () => {
  return <RouterProvider router={router} />;
};

export default App;

Eu tenho o seguinte código, que gostaria de acelerar:

foreach (var workflow in closedWorkflows)
{
    var w = relatedWorkflows.FirstOrDefault(r => r.Fingerprint != workflow.Fingerprint && r.TradeDate == workflow.TradeDate);
    if (w != null)
    {
        relatedWorkflows.Add(workflow);
    }
}

relatedWorkflowse closedWorkflowssão uma lista do mesmo tipo de objetos. Pensei em criar uma pesquisa ou dicionário com uma classe ou tupla anônima em Fingerprintand TradeDate, mas uma verificação é para igualdade e outra é para desigualdade. Seria uma boa abordagem criar pesquisas TradeDatee, em seguida, criar pesquisas Fingerprint para cada lista de pesquisa de TradeDate?

Atualizada:

Um MUITO obrigado a @Dmitry Bychenko.

No meu teste a diferença é de 41486 ms vs 26ms!!!

Meu professor na universidade deu esta tarefa para iniciar um novo tópico em aula. Apenas uma GUI simples que supostamente mostra um gráfico. 3 Arquivos foram elaborados pelo nosso Prof:

Tela de Função

package Aufgabe1.jfx;

import javafx.scene.canvas.Canvas;
import javafx.scene.canvas.GraphicsContext;
import javafx.scene.paint.Color;

final class FunctionCanvas extends Canvas
{
    private double c1 = 1, d1 = 0, c2 = 1, d2 = 0;

    void setFunctionParameters(double c1, double d1, double c2, double d2)
    {
        this.c1 = c1;
        this.d1 = d1;
        this.c2 = c2;
        this.d2 = d2;
    }

    FunctionCanvas() {}

    private static final float v = 244f / 255;
    private static final Color backGroundColor = Color.color(0, 0, 0);
    private static final int yOffset = 20;

    void drawFunctionCurve() {
        GraphicsContext gc = getGraphicsContext2D();
        //float v = 244f / 255;
        gc.setFill(backGroundColor);
        gc.fillRect(0, 0, getWidth(), getHeight());

        double h = this.getHeight() - 2 * yOffset;
        int xOffset = 40;
        double w = this.getWidth() - 2 * xOffset;
        double yZero = yOffset + h / 2;
        gc.setFill(Color.BLACK);
        gc.fillText("f(x)", xOffset - 30, yOffset);
        gc.fillText("0", xOffset - 25, yZero + 5);
        gc.fillText("2\u03c0", xOffset + w - 5, yZero - 5);
        gc.setLineWidth(1.0);
        gc.setStroke(Color.GRAY);
        gc.strokeLine(xOffset, yOffset, xOffset, yOffset + h);
        gc.strokeLine(xOffset, yZero, xOffset + w, yZero);
        gc.setLineWidth(1.5);
        gc.setStroke(Color.INDIANRED);
        for (int x = 0; x < w; x++) {
            int y = (int) ((h / 2) * sinCosFunc(x * 2 * Math.PI / w));
            gc.strokeLine(xOffset + x, yZero - y, xOffset + x, yZero - y);
        }
    }

    private double sinCosFunc(double x)
    {
        return Math.sin(c1 * x + d1) * Math.cos(c2 * x + d2);
    }
}

CurvaFuncional

package Aufgabe1.jfx;

import javafx.application.Application;
import javafx.fxml.FXML;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.scene.layout.AnchorPane;
import javafx.stage.Stage;

public class FunctionCurve extends Application {
    public FunctionCurve() { }
    @Override
    public void start(Stage stage) throws Exception {
        int width = 670;
        int height = 520;
        //Written by me
        FXMLLoader loader = new FXMLLoader(getClass().getResource("1gui.fxml"));
        Parent root = loader.load();
        Scene scene = new Scene(root, width, height);
        stage.setTitle(this.getClass().getSimpleName());
        stage.setScene(scene);
        stage.centerOnScreen();
        stage.show();

    }
}

Principal

package Aufgabe1.jfx;

final class Main
{
    private Main() {}

    public static void main(String[] args)
    {
        javafx.application.Application.launch(FunctionCurve.class, args);
    }
}

Eu já criei o arquivo FXML e escrevi o controlador com o melhor de minhas habilidades:

FXML

<?xml version="1.0" encoding="UTF-8"?>

<?import javafx.geometry.*?>
<?import javafx.scene.control.*?>
<?import javafx.scene.layout.*?>

<SplitPane dividerPositions="0.08892617449664429" maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" orientation="VERTICAL" prefHeight="400.0" prefWidth="600.0" xmlns="http://javafx.com/javafx/17.0.2-ea" xmlns:fx="http://javafx.com/fxml/1" fx:controller="Aufgabe1.jfx.Controller">
  <items>
    <AnchorPane minHeight="0.0" minWidth="0.0" prefHeight="100.0" prefWidth="160.0">
         <children>
            <HBox prefHeight="48.0" prefWidth="597.0">
               <children>
                  <Label prefHeight="25.0" prefWidth="25.0" text="c1">
                     <padding>
                        <Insets left="5.0" right="5.0" />
                     </padding>
                  </Label>
                  <Spinner editable="true" prefHeight="10.0" prefWidth="50.0" />
                  <Label prefHeight="25.0" prefWidth="25.0" text="d1">
                     <padding>
                        <Insets left="5.0" right="5.0" />
                     </padding>
                  </Label>
                  <Spinner editable="true" prefHeight="10.0" prefWidth="50.0" />
                  <Label prefHeight="25.0" prefWidth="25.0" text="c2">
                     <padding>
                        <Insets left="5.0" right="5.0" />
                     </padding>
                  </Label>
                  <Spinner editable="true" prefHeight="10.0" prefWidth="50.0" />
                  <Label prefHeight="25.0" prefWidth="25.0" text="d2">
                     <padding>
                        <Insets left="5.0" right="5.0" />
                     </padding>
                  </Label>
                  <Spinner editable="true" prefHeight="10.0" prefWidth="50.0" />
                  <Button mnemonicParsing="false" text="Button">
                     <HBox.margin>
                        <Insets left="5.0" right="5.0" />
                     </HBox.margin>
                  </Button>
                  <Button mnemonicParsing="false" text="reset">
                     <HBox.margin>
                        <Insets left="5.0" right="5.0" />
                     </HBox.margin>
                  </Button>
               </children>
            </HBox>
         </children></AnchorPane>
      <AnchorPane fx:id="_canvas" prefHeight="600.0" prefWidth="400.0" />
  </items>
</SplitPane>

Controlador

package Aufgabe1.jfx;

import javafx.fxml.FXML;
import javafx.scene.layout.AnchorPane;

public class Controller {

    @FXML
    private AnchorPane _canvas ;

    // called by the FXML loader after the labels declared above are injected:
    public void initialize() {
        FunctionCanvas c = new FunctionCanvas();
        _canvas.setPrefWidth(400);
        _canvas.setPrefHeight(300);
        _canvas.getChildren().add(c);
        c.drawFunctionCurve();

    }
}

Tentei praticamente todas as soluções que encontrei na web, mas sempre que executo o aplicativo a tela com o gráfico não aparece. Estou trabalhando com o IntelliJ IDEA, se isso importa ...

Eu tenho um DataFrame Polars contendo uma coluna com strings representando exposições 'esparsas' do setor, assim:

pl.DataFrame(
    [
        pl.Series("sector_exposure", [
            'Technology=0.207;Financials=0.090;Health Care=0.084;Consumer Discretionary=0.069', 
            'Financials=0.250;Health Care=0.200;Consumer Staples=0.150;Industrials=0.400'
            ], dtype=pl.String),
    ]
)

Quero "descompactar" essa string em novas colunas para cada setor (por exemplo, Tecnologia, Finanças, Saúde) com valores associados ou uma estrutura polar com nomes de setores como campos e valores de exposição.

Estou procurando uma solução mais eficiente usando apenas expressões polares, sem recorrer a loops Python (ou funções mapeadas em python). Alguém pode fornecer orientação sobre como fazer isso?

Foi isso que descobri até agora - que funciona na produção da estrutura desejada, mas é um pouco lento.

(
    df["sector_exposure"]
    .str
    .split(";")
    .map_elements(lambda x: {entry.split('=')[0]: float(entry.split('=')[1]) for entry in x},
                  skip_nulls=True,
                  )
)

Obrigado!