Estou tentando alterar a fonte no meu gráfico para Times New Roman, mas, por algum motivo, a fonte do expoente no rótulo do meu eixo x não muda.
Eu configurei os parâmetros globais da seguinte forma:
plt.rcParams["font.family"] = "Times New Roman"
O que funciona bem, exceto pela parte dentro das chaves.
plt.xlabel("Stromdichte A cm$^{-2 test}$", fontsize=40)
Ao tentar obter o primeiro ou último índice de uma string ilimitada, conforme mostrado neste programa
with Ada.Strings; use Ada.Strings; -- for `Backward`
with Ada.Strings.Unbounded;
with Ada.Text_IO; use Ada.Text_IO;
procedure Foo is
package U_Str renames Ada.Strings.Unbounded;
S : U_Str.Unbounded_String := U_Str.To_Unbounded_String ("example unbounded string");
I : Natural := U_Str.Index (Source => S,
Pattern => "s",
Going => Backward,
From => S'Last);
begin
Put_Line (I'Image);
end Foo;
GNAT reclama de U_Str.Unbounded_Stringser um tipo privado:
$ gnatmake foo.adb
x86_64-linux-gnu-gcc-10 -c foo.adb
foo.adb:12:41: prefix for "Last" attribute may not be private type
gnatmake: "foo.adb" compilation error
Não entendi isso, o mesmo programa com um regular Stringfunciona bem:
with Ada.Strings; use Ada.Strings; -- for `Backward`
with Ada.Strings.Fixed;
with Ada.Text_IO; use Ada.Text_IO;
procedure Foo is
package F_Str renames Ada.Strings.Fixed;
S : String := "example fixed string";
I : Natural := F_Str.Index (Source => S,
Pattern => "s",
Going => Backward,
From => S'Last);
begin
Put_Line (I'Image);
end Foo;
$ gnatmake foo.adb
x86_64-linux-gnu-gcc-10 -c foo.adb
x86_64-linux-gnu-gnatbind-10 -x foo.ali
x86_64-linux-gnu-gnatlink-10 foo.ali
$ ./foo
15
As strings ilimitadas não têm atributos 'Firstand 'Last? O Manual de Referência Ada apenas afirma
Os seguintes atributos são definidos para um prefixo A que é de um tipo de matriz (após qualquer desreferência implícita) ou denota um subtipo de matriz restrito
mas não diz nada sobre tipos privados. Isso é um bug do GNAT ou eu perdi alguma coisa?
Estou tentando fazer algum gerenciamento de arquivos no bash e tenho strings neste formato:
1 dir/hello.txt
2 dir2/bar.jpg
Quando executo esta substituição: ${FOO/[:space:]*/Hello}
obtenho este resultado:1 dir/hHello
O objetivo é substituir tudo após o primeiro espaço (incluindo o espaço) porHello
Parece um bug para mim. Nesse caso, confirme e eu levarei o problema para o upstream.
Forneci 2 implementações diferentes de segmentos de comutação ao calcular o comprimento da string. Não entendo por que estamos comutando o segmento extra e o segmento de dados ou, mais precisamente, copiando o conteúdo do segmento de dados (registro DS) para o segmento extra (registro ES). Se eu remover as linhas push dse pop eso resultado não mudar, mas quando eu substituir les di, [bp+4]pela mov di, [bp+4] mensagem é exibida na tela, mas com um monte de outros caracteres diferentes.
Por que isso está acontecendo? Sou novo em assembly.
org 0x0100
jmp start
message: db 'Hello world!', 0 ; First string to be concatenated
; Subroutine to calculate the length of a string
; Takes the segment and offset of a string as parameters
strlen:
push bp
mov bp, sp
push es
push cx
push di
les di, [bp+4] ; Point es:di to string
mov cx, 0xffff ; Load maximum number in cx
xor al, al ; Load a zero in al
repne scasb ; Find zero in the string
mov ax, 0xffff ; Load maximum number in ax
sub ax, cx ; Find change in cx
dec ax ; Exclude null from length
pop di
pop cx
pop es
pop bp
ret 4
; Subroutine to print a string
; Takes the x position, y position, attribute, and address of a null-terminated string as parameters
printstr:
push bp
mov bp, sp
pusha
push di
push ds ; Push segment of string
mov ax, [bp+4]
push ax ; Push offset of string
call strlen ; Calculate string length
cmp ax, 0 ; Is the string empty?
jz exit ; No printing if string is empty
mov cx, ax ; Save length in cx
mov ax, 0xb800 ; Video memory base address
mov es, ax ; Point es to video base
mov al, 80 ; Load al with columns per row
mul byte [bp+8] ; Multiply with y position
add ax, [bp+10] ; Add x position
shl ax, 1 ; Turn into byte offset
mov di, ax ; Point di to required location
mov si, [bp+4] ; Point si to string
mov ah, [bp+6] ; Load attribute in ah
cld ; Clear direction flag for auto-increment mode
nextchar:
lodsb ; Load next char in al
stosw ; Print char/attribute pair
loop nextchar ; Repeat for the whole string
exit:
pop ds
pop di
popa
pop bp
ret 8
start:
mov ax, 30
push ax ; Push x position
mov ax, 20
push ax ; Push y position
mov ax, 0x7 ; Blue on white attribute
push ax ; Push attribute
mov ax, message
push ax ; Push address of message
call printstr ; Call the printstr subroutine
mov ax, 0x4c00 ; Terminate program
int 0x21
Versão alternativa:
push bp
mov bp, sp
pusha
push ds
pop es ; load ds in es
mov di, [bp+4] ; point di to string
mov cx, 0xffff ; load maximum number in cx
xor al, al
repne scasb
mov ax, 0xffff
sub ax, cx
dec ax
jz done
mov cx, ax
...
Primeira vez que posto aqui, estou recebendo alguns erros em um antigo programa BASIC de 1977 para o computador Sol 20.
O primeiro erro é um "erro DM na linha 4240":
4220 PRINT " TYPE IN -STOP- TO QUIT ANYTIME"
4230 PRINT
4240 DIM A$(30),B$(30),C$(45),D$(30),E$(30),L$(10),Z$(12)
4250 LET A$="NO SUCH ELEVATION IN MY TAPES, UNDER 360, PLEASE."
4260 PRINT " THE TANK IS ";E;" FEET AWAY."
Se eu remover o "B$(30)" da linha 4240, o programa continua sendo executado, mas recebo um "erro BS na linha 4590" abaixo:
4560 IF I<=0 THEN 5250
4570 IF S=0 OR Z=3 THEN 4590
4580 LET S=-S
4590 LET D=(2*X**3*SIN(2*W)*COS(.5*W)/G*4)
4600 LET D=INT(D/15-(3*S-7))
4610 PRINT
4620 PRINT " ";D;" FEET"
Se eu remover um "*" depois do "X", o programa roda, mas o intervalo é muito baixo. Qualquer um que esteja familiarizado com BASIC pode ser capaz de ver uma falha ou fazer algumas sugestões.
Anteriormente, quando eu usava o .NET 8, eu podia usar String.Joindentro da Selectinstrução para um IQueryable, como mostrado neste código:
var receiveTransactions = await repository.Context.Set<ReceiveTransaction>()
.Select(x => new ThirdPartyTransactionReportModel
{
Date = x.Created,
Customer = string.Join(" - ", x.CustomerIdentity.Customer.Name, x.CustomerIdentity.Customer.Type, x.CustomerIdentity.Customer.Nationality.Name),
})
.ToListAsync();
Entretanto, após atualizar para o .NET 9, estou encontrando um erro:
A árvore de expressão não pode conter o valor da estrutura ref ou do tipo restrito 'ReadOnlySpan'.
Por favor, forneça-me alguma solução ou substituição para corrigir esse problema.
Pelo que entendi dessa pergunta , há muitas maneiras de interpretar a ordem de duas strings.
Rust fornece uma implementação padrão para Ordfor str, mas não consigo encontrar a resposta para estas perguntas:
Tenho uma variável chamada BB_NP e quero adicionar o conteúdo dela (string) a um arquivo de texto de saída com uma data/hora, ou seja, apenas um arquivo de log básico.
Adicionar-Conteúdo -Caminho ".\LogFile.txt" -Valor $(Get-Date) ($BB_NP)
Toda vez que tento, não importa qual combinação (envolver ou não, etc.), ele só consegue fazer uma coisa, e não as duas. Acredito que seja devido aos dois tipos diferentes de dados.
Como posso gravar em um arquivo de texto a data/hora e então concatenar o conteúdo da variável BB_NP?
Obrigado!.
Estou tentando criar o que espero da subrotina (GetAllPosition). Não sei onde usar RsultOfPostionAndLengthno código para obter a saída esperada
Minha expectativa de saída para ( RsultOfPostionAndLength ):
MultiSplit' For {"C", "B", "A"}é: 55-5 '}666[' 61-5']777(' 67-3')8[' 71-6']hhhy('
MultiSplit' For {"A", "B", "C"}é: 27-6 ']1111{' 34-4'}22(' 39-7')33333{' 47-3'}4{' 51-3 '}5{' 55-5'}666[' 78-4')99{' 83-5'}999['
Dim RsultOfPostionAndLength As List(Of String) 'Pattern is Position of String And Length Of Find
' 'MultiSplit' For {"C", "B", "A"} is: 55-5 '}666[' 61-5']777(' 67-3')8[' 71-6']hhhy('
' 'MultiSplit' For {"A", "B", "C"} is: 27-6 ']1111{' 34-4'}22(' 39-7')33333{' 47-3'}4{' 51-3 '}5{' 55-5'}666[' 78-4')99{' 83-5'}999['
Sub Setup()
Dim inString As String = "}666[]777([}666[]777(]00[A]1111{C}22(B)33333{C}4{C}5{C}666[A]777(B)8[A]hhhy(B)99{C}999[A]101010}666[]777("
Dim MultiSplit As String() = {"C", "B", "A"}
GetAllPosition(1, inString.Length, inString, MultiSplit, 0)
End Sub
Sub GetAllPosition(LastIdx As Integer, LastLen As Integer, inString As String, MultiSplit As String(), Level As Integer)
Dim spl As String() = Split(inString, ",")
Dim body As String = Mid(inString, LastIdx, LastLen)
'Dim LastIdx As Integer = spl(0)
Dim results As New List(Of String)
Dim Find As String = MultiSplit(Level)
Dim last As Integer = LastIdx
Dim index As Integer = -1
Do Until body.Length <= index
index = body.IndexOf(Find, index + 1)
If index = -1 AndAlso body.Length > last Then
index = body.Length
End If
Dim lenTexxt As Integer = Math.Abs(last - index) + 1
Dim part1 As String = Mid(body, last, lenTexxt)
Dim part As String = Mid(inString, last, lenTexxt)
Dim b As Boolean = MultiSplit.Skip(Level + 1).All(Function(c) part.IndexOf(c, comparisonType:=StringComparison.OrdinalIgnoreCase) > -1)
If b Then
results.Add(last & "," & lenTexxt & "," & part)
End If
last = index + 2
Loop
Level += 1
For Each g In results
Dim spl2 As String() = Split(g, ",")
GetAllPosition(spl2(0), spl2(1), inString, MultiSplit, Level)
Next
End Sub
Às vezes, preciso me encontrar truncando uma string para caber em um número específico de bytes. O problema de fazer isso em Go é que se você fizer isso s[:1_000_000], dado que sé uma string utf-8 válida , você pode acabar cortando bem no meio de um ponto de código utf-8 que pode ter de 1 a 4 bytes de comprimento, deixando você com uma runa inválida.
Algumas pessoas (e os LLMs treinados em suas ideias) tentariam usar utf8.ValidString, ou for i := range sfazer isso, pois ambos garantiriam uma runa válida. No entanto, essas pessoas estariam fazendo uma tarefa de tempo constante em tempo linear.
Eu escrevi uma função de truncamento seguro de tempo constante:
import "unicode/utf8"
// UTF8SafeTruncateNBytes Truncates a **valid** utf-8 string `s` to `n` bytes (not n UTF-8 characters),
// ensuring that the string is not truncated in the middle of a UTF-8 character.
func UTF8SafeTruncateNBytes(s string, n int) string {
if n >= len(s) {
return s
}
for i := n; i >= n-3 && i >= 0; i-- {
if utf8.RuneStart(s[i]) {
return s[:i]
// Edit: This was:
//if r, size := utf8.DecodeRuneInString(s[i:]); r != utf8.RuneError {
// return s[:i+size]
//}
// but got fixed because of the picked solution. This implementation is now correct,
// and, in fact, equivalent, except that it only checks one byte instead of backing up forever.
}
}
// Fallback in the case that the user lied, and passed a string that is not a valid utf-8 string.
// It would be wise to return an error or "" here if this is a standard-library
// function to allow the user to check for it.
return s[:n]
}
As perguntas são as seguintes:
"unicode/utf8"? Parece que é o nível certo de frequência de uso e complexidade para garantir ter uma função de biblioteca padrão. Devo propor isso na página de problemas deles ?