All perguntas(coding)

Tenho 2 tabelas: UserOrdersActivity e Orders

Com essa consulta posso dar uma olhada em ambos:

SELECT a.UserID,        
  b.[Order Price] AS [Total Fees]
FROM #UserOrdersActivity a, #Orders b 
WHERE a.OrderID = b.OrderID 
ORDER BY a.UserID ASC;

O que estou procurando é que usuários com mais de um pedido SOMAR o preço do pedido:

SELECT a.UserID,        
  sum(b.[Order Price]) AS [Total Fees]
FROM #Orders b
INNER JOIN #UserOrdersActivity a ON a.OrderID = b.OrderID    
GROUP BY a.UserID

Acho que talvez eu devesse agrupar pelo preço do pedido e conseguir apresentar os dados pelo ID do Usuário, mas estou com algumas dificuldades. Basicamente, o resultado esperado seria que IDs de Usuário repetidos combinassem o preço do pedido em uma única linha.

Estou construindo um esquema Aque possui uma propriedade que faz referência a outro esquema B. O problema é que preciso apenas de um subconjunto de uma propriedade enum no esquema B. Existe uma maneira de fazer isso dentro do arquivo yaml? Exemplo simplificado: se eu estivesse construindo algo para um consultório veterinário:

components:
  schemas:
    Dog:
      properties:
        color:
          description: Color of the dog
          $ref: "#/comonents/schema/color"
        injury:
          description: Information about the injury
          $ref: "#/comonents/schema/InjuryInfo"
    
    InjuryInfo:
      properties:
        location:
          description: where on the animal is the injury
          type: string
          enum: 
            - Body
            - Leg
            - Wing
        details:
          description: Additional Details
          type: string
        otherProperty:
          description: Some other property
          type: string

O que preciso fazer é reutilizar o InjuryInfoesquema, mas preciso Dogque ele permita apenas propriedades InjuryInfo.locatione InjuryInfo.details. E que Dog.injury.locationinclua apenas um subconjunto dos valores de enumeração. Isso é possível a partir do arquivo yaml?

Prezados, comecei a desenvolver um código VBA que deve: 1- pedir para o usuário selecionar uma face de qualquer corpo no CATPART atual. 2- uma vez feito isso, o VBA deve extrair essa superfície em um conjunto geométrico e criar 3 pontos no contorno dessa superfície. 3- com base nesses pontos, criar um plano e, por fim, projetar o contorno da superfície dentro de um esboço.

abaixo do meu código, não funciona. Ele exibe incompatibilidade de tipo sem especificar onde.

A imagem descreve mais ou menos o que eu quero. NB: a parte do gato pode conter formas complexas, por isso a superfície extraída precisa estar em tangência

Sub ExtractSurfaceAndCreateSketch()
    Dim partDocument As Object
    Dim part1 As Object
    Dim selection1 As Object
    Dim face1 As Object
    Dim hybridShapeFactory As Object
    Dim hybridBody As Object
    Dim reference1 As Object
    Dim hybridShapeExtract As Object
    Dim hybridShapePoint As Object
    Dim sketch As Object
    Dim sketches As Object

    ' Initialize CATIA Document and Part
    Set partDocument = CATIA.activeDocument
    Set part1 = partDocument.part
    Set selection1 = partDocument.selection
    
    ' Clear previous selections
    selection1.Clear
    
    ' Prompt user to select a face
    MsgBox "Please select a face from a body."
    
    ' Select the face
    On Error Resume Next
    Dim result As Variant
    result = selection1.SelectElement2("Face", "Select a face", False)
    If Err.Number <> 0 Then
        MsgBox "Error during selection: " & Err.Description
        Err.Clear
        Exit Sub
    End If
    On Error GoTo 0
    
    ' Check the type of the result and compare accordingly
    If VarType(result) = vbString Then
        If result <> "Normal" Then
            MsgBox "No valid face selected. Exiting."
            Exit Sub
        End If
    Else
        MsgBox "Unexpected return type from SelectElement2. Exiting."
        Exit Sub
    End If
    
    ' Get the selected face
    If selection1.Count = 0 Then
        MsgBox "No face selected. Exiting."
        Exit Sub
    End If
    Set face1 = selection1.Item(1).Value
    
    ' Create a reference from the face
    On Error GoTo ErrorHandler
    Set reference1 = part1.CreateReferenceFromBRepName(face1.brepName)
    
    ' Create the Hybrid Shape Factory and Hybrid Body
    Set hybridShapeFactory = part1.hybridShapeFactory
    Set hybridBody = part1.hybridBodies.Add
    
    ' Extract the surface from the face
    Set hybridShapeExtract = hybridShapeFactory.AddNewExtract(reference1)
    hybridShapeExtract.Name = "ExtractedSurface"
    hybridBody.AppendHybridShape hybridShapeExtract
    
    ' Create points on the outline of the extracted surface
    Dim posX As Variant, posY As Variant
    Dim pointArray(2) As Object
    
    ' Define UV coordinates for point placement
    posX = Array(0.1, 0.5, 0.9) ' X coordinates
    posY = Array(0.1, 0.5, 0.9) ' Y coordinates
    
    Dim i As Integer
    For i = 0 To 2
        ' Create a point on the extracted surface using UV coordinates
        Set hybridShapePoint = hybridShapeFactory.AddNewPointOnSurface(reference1, posX(i), posY(i))
        hybridBody.AppendHybridShape hybridShapePoint
        Set pointArray(i) = hybridShapePoint ' Store the points for plane creation
    Next i
    
    ' Create a plane based on the three points
    Dim hybridShapePlane As Object
    Set hybridShapePlane = hybridShapeFactory.AddNewPlaneThroughPoints(pointArray(0), pointArray(1), pointArray(2))
    hybridBody.AppendHybridShape hybridShapePlane
    
    ' Create a sketch on the new plane
    Set sketches = part1.sketches
    Set sketch = sketches.Add(hybridShapePlane)
    
    ' Extract the projected profile of the extracted surface
    Dim projectedProfile As Object
    Set projectedProfile = hybridShapeFactory.AddNewProjection(hybridShapeExtract, hybridShapePlane)
    projectedProfile.Name = "ProjectedProfile"
    hybridBody.AppendHybridShape projectedProfile
    
    ' Set the sketch as editable
    Dim sketcherEditor As Object
    Set sketcherEditor = sketch.OpenEdition()
    
    ' Create lines based on the projected profile
    Dim iCurve As Integer
    Dim profile As Object

    ' Loop through all segments of the projected profile
    For iCurve = 1 To projectedProfile.Profiles.Count
        ' Get the profile curve
        Set profile = projectedProfile.Profiles.Item(iCurve)

        ' If it's a line, extract its start and end points
        If profile.Type = "Line" Then
            Dim startPoint As Object
            Dim endPoint As Object
            
            ' Retrieve the start and end points
            Set startPoint = profile.GetStartPoint()
            Set endPoint = profile.GetEndPoint()
            
            ' Create a line in the sketch using the Factory2D
            Dim factory2D As Object
            Set factory2D = sketcherEditor.factory2D
            
            ' Create the line in the sketch
            On Error Resume Next
            factory2D.CreateLine startPoint.X, startPoint.Y, endPoint.X, endPoint.Y
            If Err.Number <> 0 Then
                MsgBox "Error creating line: " & Err.Description
                Err.Clear
            End If
            On Error GoTo 0
        End If
    Next iCurve
    
    ' Close the sketch edition
    sketch.CloseEdition
    
    ' Update the part
    part1.Update
    
    MsgBox "Surface extracted, points created, plane established, and sketch projected successfully!"

    Exit Sub

ErrorHandler:
    MsgBox "Error: " & Err.Description
    Exit Sub
End Sub

Estou tentando executar a versão mais recente do Python no meu sistema Linux Ubuntu 24.04, mas a versão mais antiga ainda aparece como atual. Há dois locais onde o Python está configurado: '/usr/bin' e '/usr/local/bin'. Como devo lidar com isso para obter a configuração correta no meu sistema?

Eu tentei ~-> $ python --versione a resposta é Python 3.12.3
, mas quando tento ~-> $ python3 --versiona resposta é Python 3.13.3

Instalação do Python

Tenho uma referência e sequências de consulta:

ref_seq <- "ATTT"
df <- data.frame(V1=c("AATT", "TTTT", "GGTT"))

Gostaria de retornar as posições incompatíveis na sequência para cada consulta em comparação com a referência:

seqdiff <- function(seq1, seq2) {
  seq <- strsplit(c(seq1, seq2), split= '')
  mismatches <- which(seq[[1]] != seq[[2]])
  return(mismatches)
}
    
apply(X=df, MARGIN=2, function(x) seqdiff(x, ref_seq))

#      V1
# [1,]  1
# [2,]  2

Resultado esperado:

#      V1
# [1,]  2
# [2,]  1
# [3,]  1 2

Estou usando a detailstag maravilhosa da seguinte maneira, que expande o conteúdo quando um link é clicado:

summary::marker {
  content: " ";
}

summary {
  color: blue;
  text-decoration: underline;
  cursor: pointer;

}

<details>
  <summary>Show Details</summary>
  <h2>HTML Details</h2>
  <p>Explanation of the topic</p>
</details>

Esta tag permite incluir todos os tipos de tags HTML, incluindo imagens a serem incluídas nos detalhes expandidos.

Por exemplo, o código acima mostrará primeiro o seguinte:

e quando o link "Mostrar detalhes" for clicado, o HTML será expandido para aquele tópico específico:

Observe que na forma expandida, o termo "Teorema de Pitágoras" está em negrito, pois usei a btag.

Funciona bem.

Mas me deparei com uma situação em que uma única página contém cerca de 300 desses tópicos, e "Mostrar detalhes" para cada um deles inclui cerca de 3 arquivos de imagem cada.

Isso significa que terei cerca de 900 imagens carregadas naquela página assim que alguém a visitar. Isso não é bom, pois o carregamento será lento e o visitante poderá clicar em apenas 1 ou 2 tópicos em expansão. Portanto, não é necessário carregar todas as 900 imagens.

Eu estava procurando uma personalização que permitisse que, ao clicar no link "Mostrar Detalhes" de um tópico específico, apenas aquele HTML específico fosse carregado e exibido. Combinar AJAX/JS é uma solução, mas o AJAX tem a limitação de não fechar o link expandido anteriormente automaticamente.

Algo como combinar a detailstag e o AJAX, de modo que a expansão de uma mostre aquela imagem específica e feche a outra imagem. ( detailsa tag permite que apenas um elemento clicado seja exibido e fecha automaticamente o clicado anteriormente).

Tenho lutado para obter uma regex que possa capturar dados extraídos de um arquivo PDF não tão limpo:

Cada linha deve conter 1. ID da escola (5 dígitos), 2. nome da escola, 3. número da inscrição, 4. outro número (=número da oferta)

Uma linha limpa se parece com "10394 ABC School 50 34" e pode ser capturada usando ([0-9]{5})\s{2,}(\D+)\s+(\d*)\s+(\d*). Um caso normal se parece com https://regex101.com/r/Mwv3bJ/1 , ignore o lookbehind negativo.

O problema com o qual tenho dificuldade é que algumas escolas têm um código postal parcial (1 ou 2 letras do alfabeto seguido de 1 ou 2 dígitos, como W19 ou SW2) no nome , então "10422 XYZ College W9 60 33" será capturado como (id: 10422)(escola: XYZ College W)(inscrições: 9)(ofertas: 60). https://regex101.com/r/YeNmT7/1

Quero que o (3:application#) não capture nenhum dígito imediatamente precedido por um alfabeto e, se tal \D{1,2}\d{1,2} existir no nome, seja capturado por (2:nome da escola). Tentei um grupo sem captura (?:^\D{1,2}\d{1,2}$) para me livrar de qualquer CEP em potencial, mas não funcionou.

Exemplos:

• 18747 Escola ABC 50 14 //(18747)(Escola ABC)(50)(14)
• 17646 Escola EFG W11 190 44 //(17646)(Escola EFG W11)(190)(44)

Por favor, avise.

Então eu tenho esta função:

import numpy as np
import numba as nb


@nb.njit(cache=True, parallel=True, nogil=True)
def triangle_half_UR_LL(size: int, swap: bool = False) -> tuple[np.ndarray, np.ndarray]:
    total = (size + 1) * size // 2
    x_coords = np.full(total, 0, dtype=np.uint16)
    y_coords = np.full(total, 0, dtype=np.uint16)
    offset = 0
    side = np.arange(size, dtype=np.uint16)
    for i in nb.prange(size):
        offset = i * size - (i - 1) * i // 2
        end = offset + size - i
        x_coords[offset:end] = i
        y_coords[offset:end] = side[i:]
    
    return (x_coords, y_coords) if not swap else (y_coords, x_coords)

O que ele faz não é importante, o importante é que ele é compilado com JIT e Numba e, portanto, muito rápido:

In [2]: triangle_half_UR_LL(10)
Out[2]:
(array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
        2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5,
        5, 6, 6, 6, 6, 7, 7, 7, 8, 8, 9], dtype=uint16),
 array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9, 2, 3, 4,
        5, 6, 7, 8, 9, 3, 4, 5, 6, 7, 8, 9, 4, 5, 6, 7, 8, 9, 5, 6, 7, 8,
        9, 6, 7, 8, 9, 7, 8, 9, 8, 9, 9], dtype=uint16))

In [3]: %timeit triangle_half_UR_LL(1000)
166 μs ± 489 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

In [4]: %timeit triangle_half_UR_LL(1000)
166 μs ± 270 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

In [5]: %timeit triangle_half_UR_LL(1000)
166 μs ± 506 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

Agora, se eu definir outra função e compilá-la JIT com o Numba, o desempenho da função rápida cai inexplicavelmente:

In [6]: @nb.njit(cache=True)
   ...: def dummy():
   ...:     pass

In [7]: dummy()

In [8]: %timeit triangle_half_UR_LL(1000)
980 μs ± 20 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

In [9]: %timeit triangle_half_UR_LL(1000)
976 μs ± 9.9 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

In [10]: %timeit triangle_half_UR_LL(1000)
974 μs ± 3.11 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

Isso é real, já reproduzi esse problema com sucesso muitas vezes, sem falhas. Inicio uma nova sessão do interpretador, colo o código e ele roda rápido. Defino a função fictícia, chamo a função fictícia e a função rápida fica inexplicavelmente mais lenta.

Captura de tela como prova:

Estou usando o Windows 11 e não tenho a mínima ideia do que está acontecendo.

Existe alguma explicação para isso? E como posso evitar esse problema?

Curiosamente, se eu me livrar do nogilparâmetro e sem alterar mais nada, o problema desaparece magicamente:

In [1]: import numpy as np
   ...: import numba as nb
   ...:
   ...:
   ...: @nb.njit(cache=True, parallel=True)
   ...: def triangle_half_UR_LL(size: int, swap: bool = False) -> tuple[np.ndarray, np.ndarray]:
   ...:     total = (size + 1) * size // 2
   ...:     x_coords = np.full(total, 0, dtype=np.uint16)
   ...:     y_coords = np.full(total, 0, dtype=np.uint16)
   ...:     offset = 0
   ...:     side = np.arange(size, dtype=np.uint16)
   ...:     for i in nb.prange(size):
   ...:         offset = i * size - (i - 1) * i // 2
   ...:         end = offset + size - i
   ...:         x_coords[offset:end] = i
   ...:         y_coords[offset:end] = side[i:]
   ...:
   ...:     return (x_coords, y_coords) if not swap else (y_coords, x_coords)

In [2]: %timeit triangle_half_UR_LL(1000)
186 μs ± 47.9 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [3]: %timeit triangle_half_UR_LL(1000)
167 μs ± 1.61 μs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

In [4]: %timeit triangle_half_UR_LL(1000)
166 μs ± 109 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

In [5]: @nb.njit(cache=True)
   ...: def dummy():
   ...:     pass

In [6]: dummy()

In [7]: %timeit triangle_half_UR_LL(1000)
167 μs ± 308 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

In [8]: %timeit triangle_half_UR_LL(1000)
166 μs ± 312 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

In [9]: %timeit triangle_half_UR_LL(1000)
167 μs ± 624 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

Por que isso acontece?

Mas não, se eu definir outras funções, de alguma forma a primeira função fica lenta novamente. A maneira mais simples de reproduzir o problema é simplesmente redefinindo-a:

In [7]: dummy()

In [8]: %timeit triangle_half_UR_LL(1000)
168 μs ± 750 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

In [9]: import numpy as np

In [10]: %timeit triangle_half_UR_LL(1000)
167 μs ± 958 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

In [11]: import numba as nb

In [12]: %timeit triangle_half_UR_LL(1000)
167 μs ± 311 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

In [13]: @nb.njit(cache=True, parallel=True)
    ...: def triangle_half_UR_LL(size: int, swap: bool = False) -> tuple[np.ndarray, np.ndarray]:
    ...:     total = (size + 1) * size // 2
    ...:     x_coords = np.full(total, 0, dtype=np.uint16)
    ...:     y_coords = np.full(total, 0, dtype=np.uint16)
    ...:     offset = 0
    ...:     side = np.arange(size, dtype=np.uint16)
    ...:     for i in nb.prange(size):
    ...:         offset = i * size - (i - 1) * i // 2
    ...:         end = offset + size - i
    ...:         x_coords[offset:end] = i
    ...:         y_coords[offset:end] = side[i:]
    ...:
    ...:     return (x_coords, y_coords) if not swap else (y_coords, x_coords)

In [14]: %timeit triangle_half_UR_LL(1000)
1.01 ms ± 94.3 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [15]: %timeit triangle_half_UR_LL(1000)
964 μs ± 2.02 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

A lentidão também acontece se eu definir a seguinte função e chamá-la:

@nb.njit(cache=True)
def Farey_sequence(n: int) -> np.ndarray:
    a, b, c, d = 0, 1, 1, n
    result = [(a, b)]
    while 0 <= c <= n:
        k = (n + b) // d
        a, b, c, d = c, d, k * c - a, k * d - b
        result.append((a, b))

    return np.array(result, dtype=np.uint64)

In [6]: %timeit triangle_half_UR_LL(1000)
166 μs ± 296 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

In [7]: %timeit Farey_sequence(16)
The slowest run took 6.25 times longer than the fastest. This could mean that an intermediate result is being cached.
6.03 μs ± 5.72 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [8]: %timeit Farey_sequence(16)
2.77 μs ± 50.8 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)

In [9]: %timeit triangle_half_UR_LL(1000)
966 μs ± 6.48 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

Para reutilizar o editor sem precisar dispose()de create()um novo editor, o valor pode ser alterado com editor.setValue(). Como o idioma pode ser alterado (por exemplo, para 'css')?

const editor = monaco.editor.create(document.getElementById('container'), {
  value: ['function x() {', '\tconsole.log("Hello world!");', '}'].join('\n'),
  language: 'javascript'
});

Estou recebendo este erro da diretiva router-outlet. Alguém pode me ajudar a entender o porquê, pois não tenho ideia. Todas as importações foram adicionadas ao arquivo app.module.ts, mas ainda está dizendo para verificar se router-outlet é um componente do Angular. Estou usando o Angular 19 e este erro está ocorrendo apenas nas versões mais recentes, pois o mesmo código está sendo executado nas versões anteriores.

 **app.component.html**
    
        <router-outlet></router-outlet>
    
    **app.component.ts**
    
        import { Component } from '@angular/core';
        
        @Component({
          selector: 'app-root',
          standalone:false,
          templateUrl: './app.component.html',
          styleUrl: './app.component.css'
        })
        export class AppComponent {
          title = 'angular_19';
        
        }
    
    **app.module.ts**
    
        import { CUSTOM_ELEMENTS_SCHEMA, NgModule } from "@angular/core";
    import { AppComponent } from "./app.component";
    import { BrowserModule } from "@angular/platform-browser";
    import { AppRoutingModule } from "./app.routes";
    import { DashboardComponent } from "./dashboard/dashboard.component";
    
    @NgModule({
        declarations:[
            AppComponent,
            DashboardComponent],
        imports:[
            BrowserModule,
            AppRoutingModule,
            RouterModule
        ],
        providers:[],
        bootstrap:[AppComponent],
        schemas:[CUSTOM_ELEMENTS_SCHEMA]
    
    
    })
    export class AppModule{}
    **app.router.ts**
    
    import { NgModule } from '@angular/core';
    import { RouterModule, Routes } from '@angular/router';
    import { DashboardComponent } from './dashboard/dashboard.component';
    
     const routes: Routes = [
        {
            path: '',
            redirectTo: '/dashboard',
            pathMatch: 'full',
            component: DashboardComponent
        },  
        {
            path: 'dashboard',
            component: DashboardComponent
        }
    ];
    
    @NgModule({
        imports:[RouterModule.forRoot(routes)],
        exports:[RouterModule]
    })
    export class AppRoutingModule{
    
    }
**main.ts**

import { AppComponent } from './app/app.component';
import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';


platformBrowserDynamic().bootstrapModule(AppComponent)
.catch(err=>console.error(err))