All perguntas(coding)

Eu tenho esta gramática raku:

#!/usr/bin/env raku
use v6.d;

use Grammar::Tracer;

grammar Grammar {
    token TOP {
          <city>      \v
          <state-zip> \v?
    }
    token city {
        ^^ \V* $$
    }
    token state-zip {
        ^^ <state> <.ws>? <zipcode> $$    #<.ws> is [\h* | \v]
    }
    token state {
        \w \w
    }
    token zipcode {
        \d ** 5
    }
}

class Actions {
    method TOP($/) {
        #works
        say "city is ",    $_ with $<city>.made;
        say "state is ",   $_ with $<state-zip><state>.made;
        say "zipcode is ", $_ with $<state-zip><zipcode>.made;

        #doesn't work
        say "state2 is ",   $_ with $<state>.made;
        say "zipcode2 is ", $_ with $<zipcode>.made;
    }

    method city($/)     { make ~$/ }
    method state($/)    { make ~$/ }
    method zipcode($/)  { make ~$/ }
}

my $address = q:to/END/;
Springfield,
IL 62704
END

Grammar.parse($address, :actions(Actions));

Funciona muito bem:

TOP
|  city
|  * MATCH "Springfield,"
|  state-zip
|  |  state
|  |  * MATCH "IL"
|  |  zipcode
|  |  * MATCH "62704"
|  * MATCH "IL 62704"
city is Springfield,
state is IL
zipcode is 62704
* MATCH "Springfield,\nIL 62704\n"

token <state-zip>existe para permitir que o estado e o zip residam em uma única linha ou para abranger várias linhas. Lembre-se que se trata de um MRE, por isso procuro respostas que não alterem a Gramática, mas sim os aspectos make/made das Ações.

MAS - para agilizar meu código, gostaria de poder acessar o estado e o CEP no nível superior da method TOP($/) {}ação de acordo com meus exemplos state2 e zipcode2. Tenho tentado "levantar" os valores de estado criados e tokenizar a árvore de correspondência - por exemplo, talvez algo como:

# doesn't work
method TOP($/) {
    make $<state>.made;
    make $<zip>.made;
    ...
}
method state-zip($/) {
    make $<state>.made;
    make $<zip>.made;
}

Isso é possível?

Estou tentando consultar empresas que possuem identificadores do Linkedin, ISINS, LEIs ou sites em inglês. Quero apenas uma linha de dados por empresa, se possível.

Estou lutando com a última parte, acho que identifiquei com sucesso que só quero que sites em inglês sejam preenchidos, mas os URLs reais não estão sendo preenchidos no resultado.

SELECT DISTINCT ?item ?itemLabel ?linkedin ?isin ?lei ?website WHERE {
  SERVICE wikibase:label { bd:serviceParam wikibase:language "en". }
  {
    SELECT DISTINCT ?item ?linkedin ?isin ?lei ?website WHERE {
      ?item wdt:P31 wd:Q4830453.
      {
      ?item wdt:P4264 ?linkedin.}
      UNION
      {
      ?item wdt:P946 ?isin.}
      UNION
      {
      ?item wdt:P1278 ?lei.}
      UNION
      {
      ?item wdt:P856 ?statement0.
      ?statement0 p:P856 [ps:P856 ?website ; pq:P407 wd:Q1860] }

    }
    LIMIT 100
  }
}

Os outros dados estão sendo preenchidos, mas não os sites. Também estou recebendo vários registros por empresa.

Estou migrando alguns códigos de Scala para Kotlin, observo um comportamento diferente:

Escala:

var i = 0

Iterator.continually{
  println(s"i=$i")
  i += 1
  i
}.takeWhile { 
  _ < 3
}.foreach { i =>
  println(s"I=$i")
}

Saída:

i=0
I=1
i=1
I=2
i=2

Equivalente em Kotlin:

fun <A> continousIterator(func: () -> A): Iterable<A> =
    object: Iterable<A> {
        override fun iterator() =
            object: Iterator<A> {
                override fun hasNext(): Boolean = true
                override fun next(): A = func()
            }
    }
    
var i = 0;
    
fun main() {
    continousIterator{
        println("i=$i")
        i += 1
        i
    }.takeWhile{
      it < 3
    }.forEach { 
      println("I=$it")
    }
}

Saída:

i=0
i=1
i=2
I=1
I=2

Quando temos estado, o resultado não é o mesmo, a ordem de chamada de func()e iteratorsão diferentes.

Eu quero saber porque.

Eu tenho um grande conjunto de dados que carrega essencialmente assim:

for(int i=0;i<count; i++){
   auto ptr = std::make_shared<Object>(Object());
   //do stuff with ptr
}

Isso não é ótimo para o desempenho, devido à alocação de memória ser fragmentada. O que eu quero fazer é o seguinte:

std::shared_ptr<Object[]> allObjects; //this is stored elsewhere until the program ends

allObjects.reset(new Object[count]);
for(int i=0;i<count; i++){
   auto ptr = std::weak_ptr<Object>(&allObjects[i]);
   //do stuff with ptr
}

Infelizmente, isso não compila. Posso experimentar assim:

auto ptr = std::shared_ptr<Object>(&allObjects[i]);

Isso funciona muito bem enquanto o programa é executado, mas é claro que quando todas as cópias do ptr forem destruídas, haverá um inferno a pagar. Então, eu gostaria que ptr fosse um std::weak_ptr. O array principal std::shared_ptr será armazenado até que todos os fracos_ptr sejam destruídos. Então, posso criar um std::weak_ptr para um membro indexado de um std::shared_ptr do tipo array? Estou apenas faltando alguma sintaxe? Preciso de um tipo de contêiner diferente? Ou estou perdendo algo fundamentalmente errado com a abordagem?

Tenho uma dúvida sobre como alterar os valores dos caracteres em um data.frame de acordo com combinações baseadas em duas colunas. Vou tentar dar um exemplo de como fica o data.frame

data <- data.frame(A1 = c("A", "T", "C"), A2 = c("C", "G", "T"), 
                   Ind1 = c("AA", "TG", "TT"), Ind2 = c("CA", "GT", "CT"),
                   Ind3 = c("AC", "GG", "TC"))

> data
  A1 A2 Ind1 Ind2 Ind3
1  A  C   AA   CA   AC
2  T  G   TG   GT   GG
3  C  T   TT   CT   TC

Quero alterar os valores nas colunas de Ind1 para Ind3 que não correspondem às combinações possíveis das colunas A1e A2, por exemplo, na primeira linha, A1é um Ae A2é um, Centão as combinações possíveis seriam AA, AC, CC(combinação baseada em A1, e A2naquela ordem). Portanto, o Ind2 deveria ser ACem vez de CA.

A saída desejada seria esta:

> data
  A1 A2 Ind1 Ind2 Ind3
1  A  C   AA   AC   AC
2  T  G   TG   TG   GG
3  C  T   TT   CT   CT

Eu tentei com switchmas não funciona. Qualquer ajuda seria apreciada. Obrigado

Tudo o que encontrei na Internet sobre o fiasco da ordem de inicialização estática era sobre C++, mas é verdade que se eu inicializar uma variável global de algum tipo Foo como

struct Foo {
    int flag;
    pthread_key_t key;
    void *ptrs[10];
};

Não consigo inicializar uma variável do tipo struct Foocomo static struct Foo x = { 0 };? se eu quiser obter o código correto por causa do SIOF?

Eu tenho as seguintes linhas em um arquivo

$ cat test.txt
69|1074330570|1,sip:+121345633210x3Bverstat=TN-Validation-Passed|tel:+12134565534|0
69|1077822111|2,;tel:+2223120011~sip:[email protected];|sip:[email protected]|0
69|1077988012|1,sip:+121510016070x3Bverstat=TN-Validation-Passed|tel:+136965339510x3Bnpd|0

Quero substituir a terceira e a quarta colunas do arquivo apenas por números de telefone, da seguinte forma:

69|1074330570|2134563321|2134565534|0
69|1077822111|2223120011|3123120022|0
69|1077988012|2151001607|3696533951|0

A parte boa é que todos os arquivos terão um ‘+’ na terceira e quarta colunas. Agora, a parte difícil é que às vezes obtemos 11 dígitos, conforme observado na terceira coluna da primeira linha (121345633210) e às vezes não há '1' adicionado após um '+'. Portanto, se houver 1 após o sinal de mais, exclua 1. Caso contrário, inicie o comprimento após o sinal '+'. Da mesma forma, se houver 11 dígitos, apenas a substring 10. Além disso, se houver mais de 1 número como a linha 2, preciso pegar o primeiro número após o sinal '+' apenas como 2223120011 e não 2223120051.

Eu tentei o seguinte

awk -F"|"  'BEGIN {FS="+"}{print substr($3,2,10)}' test.txt

Mas está fornecendo um valor incorreto para a segunda linha, pois precisa começar após o sinal '+'.

Chamar IEquatable.Equals de um número inteiro 0 para testar um objeto nulo deve retornar falso, mas ao usar reflexão ele retorna verdadeiro. Dado o código a seguir, eu esperaria que iEqualsretornasse equals'falso', mas o código de reflexão retorna verdadeiro, por quê? Estou em C# 7.3 e .NET Framework 4.6.2:

int zero = 0;
object nullObj = null;
var iEquals = zero.GetType().GetInterface("IEquatable`1").GetMethod("Equals");
var reflectionEquals = iEquals.Invoke(zero, new[] { nullObj }); // true
var equals = ((IEquatable<int>)zero).Equals(nullObj); // false

Gostaria de substituir String de outra String, mas apenas a última String encontrada. Por exemplo:

"ONE, TWO, THREE, FOUR".replaceLast(",", " &") // Outputs: "ONE, TWO, THREE & FOUR"

Se eu quiser visualizar a hierarquia dos conceitos do iterador C++20 , quero explicar brevemente em uma linha do que se trata cada conceito. Nada preciso, apenas um significado aproximado (a precisão está na fonte... ;-))

Tenho dificuldade em criar um bom "resumo de uma linha" para

• input_iterador
• iterador de saída
• forward_iterador

Aqui está minha visualização:

digraph iter_concepts {

rankdir = BT;

node[shape=record];

indirectly_readable [label="{indirectly_readable|... = *it}"];
indirectly_writable [label="{indirectly_writable|*it = ...}"];
weakly_incrementable [label="{weakly_incrementable|++it, one pass}"];
incrementable [label="{incrementable|++it, multi pass}"];
input_or_output_iterator [label="{input_or_output_iterator|*it}"];
sentinel_for [label="{sentinel_for|for(x : ...)}"];
sized_sentinel_for [label="{sized_sentinel_for|for(... i<sz ...)}"];
input_iterator [label="{input_iterator|}"];
output_iterator [label="{output_iterator|}"];
forward_iterator [label="{forward_iterator|}"];
bidirectional_iterator [label="{bidirectional_iterator| --it}"];
random_access_iterator [label="{random_access_iterator| it+=n, it-=n, it[n]}"];
contiguous_iterator [label="{contiguous_iterator| it ≍ pointer}"];


incrementable -> weakly_incrementable;
input_or_output_iterator -> weakly_incrementable;
sentinel_for -> input_or_output_iterator;
sized_sentinel_for -> sentinel_for;
input_iterator -> input_or_output_iterator;
input_iterator -> indirectly_readable;
output_iterator -> input_or_output_iterator;
output_iterator -> indirectly_writable;
forward_iterator -> input_iterator;
forward_iterator -> sentinel_for;
forward_iterator -> incrementable;
bidirectional_iterator -> forward_iterator;
random_access_iterator -> bidirectional_iterator;
contiguous_iterator -> random_access_iterator;

}

A imagem resultante é a que me deixa bastante satisfeito, exceto pelas caixas que faltam:

Atualização: corrigi o que faltava forward_iterator -> incrementableno gráfico (ainda não na imagem).