Estou enfrentando um problema com o código abaixo, pois se eu clicar em um acordeão, ele abrirá, mas o símbolo do ícone "+" não se transformará em "-" quando for aberto. O trecho de código abaixo não está sendo ativado.
Estou aprendendo Java, tentei fazer esse código simples, funciona, mas na saída recebo símbolos como " Liste.Verifica$Node@5f184fc6 ", pode ser porque minhas classes são estáticas? Ou talvez seja outro tipo de problema?
public class Verifica {
public static class Node
{
public int info;
public Node link;
public Node(int info)
{
this.info=info;
this.link=null;
}
}
public static class Lista {
int size = 0;
Node head;
public void InsFirst(int info) {
Node newNode = new Node(info);
if (head == null) {
head = newNode;
}
newNode.link = head;
head = newNode;
size++;
}
public void StampList() {
Node current = head;
for (int i = 0; i < size; i++) {
System.out.println(current);
current = current.link;
}
}
}
public static void main(String[] args) {
Lista lista=new Lista();
lista.InsFirst(10);
lista.StampList();
}
}
Preciso abrir o aplicativo Capturas de Tela usando o AppleScript. Tenho um Apple Mac mini M4.
Meu código não faz nada. Nenhum erro.
tell application "System Events"
keystroke "5" using {command down, shift down}
end tell
Preciso de ajuda com meu código.
A função JsontoBase64 recebe um json (parâmetro chamado jsonobj) que contém um pdf codificado em base64 (campo chamado "BytesBoleto") entre muitos outros campos.
Para cada ocorrência de "BytesBoleto", tenho que salvar um arquivo PDF chamado boletoXXX.pdf (onde XXX é 1 para a primeira ocorrência, 2 para a segunda, etc.) na área de trabalho do usuário.
Aqui está meu código:
function Base64toPDFandSave (base64String, filename) {
const fs = require('fs');
const path = require('path');
// Remove the prefix if it exists
const base64Data = base64String.replace(/^data:application\/pdf;base64,/, "");
// Define the path to save the PDF file on the user's desktop
const desktopPath = path.join(require('os').homedir(), 'Desktop');
const filePath = path.join(desktopPath, filename);
// Write the PDF file
fs.writeFile(filePath, base64Data, 'base64', (err) => {
if (err) {
console.error('Error saving the file:', err);
} else {
console.log('PDF file saved successfully at:', filePath);
}
});
}
function JsontoBase64 (jsonData, filename) {
// Verifica se jsonData é um objeto
if (typeof jsonData !== 'object' || jsonData === null) {
throw new Error("Entrada inválida: deve ser um objeto JSON.");
}
// Função recursiva para percorrer o JSON e encontrar os campos "BytesBoleto"
function procurarBytesBoleto(obj, fname, findex) {
for (const key in obj) {
console.log("......")
console.log(key + "::" + findex.toString());
if (obj.hasOwnProperty(key)) {
if (key === 'BytesBoleto' && typeof obj[key] === 'string') {
findex= findex+1;
console.log("BytesBoleto:"+findex.toString());
Base64toPDFandSave(obj[key], fname+findex.toString()+'.pdf');
} else if (typeof obj[key] === 'object') {
console.log("Recursiva:"+findex.toString());
procurarBytesBoleto(obj[key], fname, findex); // Chama a função recursivamente
}
}
}
}
procurarBytesBoleto(jsonData, filename, 0);
}
JsontoBase64 (jsonobj, 'boleto');
Meu problema é: após a execução, deveria ser salvo boleto1.pdf, boleto2.pdf, boleto3.pdf e assim por diante, mas os arquivos são todos salvos com os nomes boleto1.pdf (que está errado) - o índice não aumentou (incremento).
Você poderia me ajudar a encontrar o erro na minha função recorrente (recursão)?
Obrigado pela ajuda
Estou tentando criar um botão no meu projeto React usando TypeScript (TSX) que tenha uma aparência 3D semelhante à da imagem anexada:
Parece ter um efeito elevado e em camadas, com uma sombra que lhe dá uma sensação de profundidade. A face frontal é verde, com sombras visíveis à esquerda, inferior e direita, que lhe conferem uma aparência quadrada, quase isométrica.
Como posso replicar esse estilo em TSX e CSS? Estou procurando orientações sobre:
Como estruturar o JSX para tal botão (por exemplo, camadas div?)
Como usar CSS (ou Tailwind, se possível) para criar esta sombra e efeito 3D
Como mantê-lo responsivo e limpo?
Eu escrevi quatro funções que modificam uma matriz quadrada 2D no local, ela reflete metade da matriz quadrada delimitada por dois lados que se encontram e a diagonal correspondente de 45 graus, para a outra metade separada pela mesma diagonal.
Eu escrevi uma função para cada um dos quatro casos possíveis, para product(('upper', 'lower'), ('left', 'right'))refletir product(('lower', 'upper'), ('right', 'left')).
Eles usam o Numba para compilar Just-In-Time e são paralelizados usando numba.prangee, portanto, são muito mais rápidos que os métodos fornecidos pelo NumPy:
In [2]: sqr = np.random.randint(0, 256, (1000, 1000), dtype=np.uint8)
In [3]: %timeit x, y = np.tril_indices(1000); sqr[x, y] = sqr[y, x]
9.16 ms ± 30.9 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)
Como você pode ver, o código acima leva muito tempo para ser executado.
import numpy as np
import numba as nb
@nb.njit(cache=True, parallel=True, nogil=True)
def triangle_flip_LL2UR(arr: np.ndarray) -> None:
height, width = arr.shape[:2]
if height != width:
raise ValueError("argument arr must be a square")
for i in nb.prange(height):
arr[i, i:] = arr[i:, i]
@nb.njit(cache=True, parallel=True, nogil=True)
def triangle_flip_UR2LL(arr: np.ndarray) -> None:
height, width = arr.shape[:2]
if height != width:
raise ValueError("argument arr must be a square")
for i in nb.prange(height):
arr[i:, i] = arr[i, i:]
@nb.njit(cache=True, parallel=True, nogil=True)
def triangle_flip_LR2UL(arr: np.ndarray) -> None:
height, width = arr.shape[:2]
if height != width:
raise ValueError("argument arr must be a square")
last = height - 1
for i in nb.prange(height):
arr[i, last - i :: -1] = arr[i:, last - i]
@nb.njit(cache=True, parallel=True, nogil=True)
def triangle_flip_UL2LR(arr: np.ndarray) -> None:
height, width = arr.shape[:2]
if height != width:
raise ValueError("argument arr must be a square")
last = height - 1
for i in nb.prange(height):
arr[i:, last - i] = arr[i, last - i :: -1]
In [4]: triangle_flip_LL2UR(sqr)
In [5]: triangle_flip_UR2LL(sqr)
In [6]: triangle_flip_LR2UL(sqr)
In [7]: triangle_flip_UL2LR(sqr)
In [8]: %timeit triangle_flip_LL2UR(sqr)
194 μs ± 634 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
In [9]: %timeit triangle_flip_UR2LL(sqr)
488 μs ± 3.26 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
In [10]: %timeit triangle_flip_LR2UL(sqr)
196 μs ± 501 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
In [11]: %timeit triangle_flip_UL2LR(sqr)
486 μs ± 855 ns per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
Por que eles têm tempos de execução tão diferentes? Dois deles levam cerca de 200 microssegundos para serem executados, os outros dois, cerca de 500 microssegundos, apesar de serem quase idênticos.
Descobri uma coisa. triangle_flip_UR2LL(arr)é o mesmo que triangle_flip_LL2UR(sqr.T)e vice-versa.
Agora, se eu transpor o array antes de chamar as funções, a tendência de desempenho se inverte:
In [109]: %timeit triangle_flip_UR2LL(sqr.T)
196 μs ± 1.15 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
In [110]: %timeit triangle_flip_LL2UR(sqr.T)
490 μs ± 1.24 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
Por que isso está acontecendo?
Acabei de inicializar um projeto Spring Boot 3.4.4, com Gradle - Groovy, Linguagem - Java 24.
Mas dizYour build is currently configured to use incompatible Java 24 and Gradle 8.13. Cannot sync the project.
Aqui está o build.gradle:
plugins {
id 'java'
id 'org.springframework.boot' version '3.4.4'
id 'io.spring.dependency-management' version '1.1.7'
}
group = 'com.mua'
version = '0.0.1-SNAPSHOT'
java {
toolchain {
languageVersion = JavaLanguageVersion.of(24)
}
}
repositories {
mavenCentral()
}
dependencies {
implementation 'org.springframework.boot:spring-boot-starter'
testImplementation 'org.springframework.boot:spring-boot-starter-test'
testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}
tasks.named('test') {
useJUnitPlatform()
}
E aqui está o /gradle/wrapper/gradle-wrapper.properties:
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
networkTimeout=10000
validateDistributionUrl=true
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
Posso facilmente fazer o downgrade para o Java 23 ou 22. Mas quero saber por que essa configuração está listada naquele site? E, mais importante, como posso fazê-la funcionar?
Estou usando o componente MudNumericField no meu projeto MudBlazor com um valor de passo de 0,5M, portanto, apenas valores como 0,5, 1,0, 1,5, etc., são permitidos. Se um usuário inserir manualmente um valor como 1,23, um erro será exibido — o que é esperado.
No entanto, se o usuário inserir 1,23 e usar as setas para cima/baixo do mouse, o novo valor se tornará 1,73 ou 0,73 (ou seja, 1,23 ± 0,5), o que eu não quero. Gostaria de arredondar o valor para uma casa decimal após cada incremento/decremento — por exemplo, passando de 1,23 para 1,5 em vez de 1,73.
Notei que OnKeyUp e OnKeyDown funcionam para interações de teclado, mas não para cliques do mouse nos botões giratórios.
Existe uma maneira de me conectar aos eventos de incremento/decremento do MudNumericField para que eu possa aplicar minha lógica de arredondamento? Ainda sou novo no MudBlazor.
Código
<MudNumericField
T="decimal"
@bind-Value="@Days"
Label="Days"
Variant="@Variant.Text"
Min="0.5M"
Max="100"
Step="0.5M"
Error="@(!IsDaysMultipleOfHalf)"
/>
Quero executar um arquivo Python 3 com Go.
Eu tentei o seguinte:
package main
import "os/exec"
func main() {
things := exec.Command("python3", "myfile.py")
things.Output()
}
Mas não consigo encontrar uma resposta.
Estou usando o Gson para analisar uma string JSON como esta:
{
"key": 1b
}
Entretanto, quando analiso isso usando JsonParser.parseString(), o valor 1bé interpretado como uma string "1b"em vez de ser analisado como um byte.
Aqui está o código que estou usando:
JsonElement element = JsonParser.parseString(json);
System.out.println(element.getAsJsonObject().get("key")); // Outputs: "1b"
Minha expectativa era que 1bfosse analisado como um byte, semelhante a como 1é analisado como um número. Existe uma maneira de fazer o Gson reconhecer 1bcomo um literal de byte?
Caso contrário, qual é a maneira recomendada de analisar esses valores pseudo-JSON que usam sufixos de tipo no estilo Java como b, s, l, etc.?
Desde já, obrigado!