Fravadona's questions

Tenho alguns arquivos com "metacaracteres" no nome, por exemplo, colchetes:

'test[txt].0',  'test[xml].0', 'test[xml].1' | % {New-Item $_} | Out-Null

Posso obter esses arquivos com um glob:

Resolve-Path -Path 'test*'

Path
----
C:\test[txt].0
C:\test[xml].0
C:\test[xml].1

Ou um único deles usando escapes de acento grave:

Resolve-Path -Path 'test`[xml`].0'

Path
----
C:\test[xml].0

Mas não consigo obter aqueles que começam com test[xml].o uso de escapes de crase e um "curinga":

Resolve-Path -Path 'test`[xml`].*'

Qual seria o correto -Patha ser utilizado?

Gostaria de validar se uma string fornecida pelo usuário é um caminho para um arquivo ou diretório.

$Path = 'some input string'

if (!(Test-Path -LiteralPath $Path)) {
  Write-Error "${Path}: No such file or directory"
  exit 1
}

O problema é que Test-Pathnão é possível diferenciar, por exemplo, um diretório de uma chave de registro...

Como posso fazer isso?

Gostaria de extrair os nós de texto que estão logo antes da tag de fechamento dos aelementos. Por exemplo, com este XML de exemplo:

<root>
  <a/>
  <a>1</a>
  <a>2<b/>3</a>
  <a>4<b/></a>
  <a><b/>5<c/></a>
</root>

O resultado esperado seria a sequência( 1, 3 )

A expressão //a/text()[last()]não é suficiente, pois ela retorna ( 1, 3, 4, 5 ), e o problema é que não vejo como adicionar a restrição: " logo antes da tag de fechamento dea ".

Dada a entrada simplificada:

[
  [ "gpu" ],
  [ "disk" ]
]

Gostaria de selecionar as matrizes cujo primeiro elemento é "gpu".

Posso fazer isso com uma condição simples:

map(select(.[0] == "gpu"))

[
  [ "gpu" ]
]

Mas não entendo o que há de errado quando tento usar o INbuiltin:

map(select(.[0] | IN(["gpu"])))

[]

Estou usando jq1.6

Tenho um arquivo XML:

<books>
  <title>Moby-Dick</title>
  <author>Herman Melville</author>
  <title>Sunrise Nights</title>
  <author>Jeff Zentner</author>
  <author>Brittany Cavallaro</author>
  <price>14.52€</price>
  <title>My Salty Mary</title>
  <author>Cynthia Hand</author>
  <author>Brodi Ashton</author>
  <author>Jodi Meadows</author>
</books>

Que eu gostaria de transformar como:

<books>
  <book>
    <title>Moby-Dick</title>
    <author>Herman Melville</author>
  </book>
  <book>
    <title>Sunrise Nights</title>
    <author>Jeff Zentner</author>
    <author>Brittany Cavallaro</author>
    <price>14.52€</price>
  </book>
  <book>
    <title>My Salty Mary</title>
    <author>Cynthia Hand</author>
    <author>Brodi Ashton</author>
    <author>Jodi Meadows</author>
  </book>
</books>

A lógica é criar um novo booksempre que encontrarmos um titlee colocar todos os nós "sem título" seguintes naquele livro.

Aqui está o que tentei até agora:

let $books := (
  doc("books.xml")/books/* =>
    fold-left((array{}, 0), function($acc, $node) {
      let
        $arr := $acc[1],
        $idx := $acc[2]
      return
        if (name($node) = "title")
        then ($arr => array:append($node), $idx+1)
        else ($arr => array:put($idx, ($arr($idx), $node)), $idx)
    })
  )[1]
return
  <books>{
    for $book in $books
    return <book>{$book}</book>
  }</books>

Mas eu entendo

<books>
  <book>
    <title>Moby-Dick</title>
    <author>Herman Melville</author>
    <title>Sunrise Nights</title>
    <author>Jeff Zentner</author>
    <author>Brittany Cavallaro</author>
    <price>14.52€</price>
    <title>My Salty Mary</title>
    <author>Cynthia Hand</author>
    <author>Brodi Ashton</author>
    <author>Jodi Meadows</author>
  </book>
</books>

À PARTE: group by não parece ser útil para resolver o problema atual, então tentei agrupar os livros em uma matriz, mas não tenho ideia se essa é a maneira correta de fazer isso; qualquer dica é bem-vinda.

Estou experimentando elementos personalizados do Vanilla e não parece possível inserir uma tag de estilo:

class MyElement extends HTMLElement {
  constructor() {
    super();
    this.attachShadow({mode: "open"});
  }
  connectedCallback() {
    this.shadowRoot.append(document.getElementById('my-element-template').content.cloneNode(true));
  }
}
window.customElements.define("my-element", MyElement);

<template id="my-element-template">
  <slot name="my-style">
    <style>
      p { color: red; }
    </style>
  </slot>
  <p>Why am I still red instead of green?</p>
</template>

<my-element>
  <style slot="my-style">
    p { color: green; }
  </style>
</my-element>

Estou tentando substituir um padrão <select>por um Select2 em um formulário existente. A lógica do formulário foi escrita em Vanilla JS, com a validação do lado do cliente deixada para o navegador.

O problema é o posicionamento da mensagem de erro gerada pelo navegador quando utilizo um componente Select2:

document.querySelectorAll("[data-is=select2]").forEach(el => {
  // the Select2 component only works with JQuery objects
  let $jqo = $(el);
  $jqo.select2({
    width: "auto",
    placeholder: el.firstElementChild.textContent
  });
  // making sure select2 works with the existing handlers
  $jqo.on("select2:select", ev => el.dispatchEvent(new Event("change")));
});

form {
  width: 20rem;
}
label {
  display: flex;
  align-items: center;
  column-gap: 1ch;
}
/* making select and Select2 occupy the remaining space */
select, .select2-container {
  flex-grow: 1;
}

<script src="https://code.jquery.com/jquery-3.7.1.slim.min.js"></script>

<script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/js/select2.min.js"></script>
<link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/select2.min.css" rel="stylesheet" />

<!-- Standard select example --!>
<form>
  <p>
    <label>
      Greetings:
      <select name="greetings" required>
        <option hidden disabled value="" selected>Select a Greetings</option>
      </select>
    </label>
  <p>
    <input type="submit" value="Standard select">
</form>

<hr>

<!-- Standard select replaced with a Select2 component !-->
<form>
  <p>
    <label>
      Greetings:
      <select data-is="select2" name="greetings" required>
        <option hidden disabled value="" selected>Select2 a Greetings</option>
      </select>
    </label>
  <p>
    <input type="submit" value="Select2 select">
</form>

Como você pode ver depois de clicar nos botões, a mensagem de validação do Select2 é colocada em <label>vez de <select>.

Como posso consertar isso? De preferência sem JQuery.

Não estou conseguindo analisar um documento XML incorporado em uma scripttag com JavaScript puro:

document.addEventListener('DOMContentLoaded', function() {
  const xmlStr = document.getElementById('xml').innerText;
  const parser = new DOMParser();
  const xmlDoc = parser.parseFromString(xmlStr,'text/xml');
  const barText = xmlDoc.getElementById('bar').textContent;
  alert(barText)
});

<body>

  <h1>Parsing &lt;script type="text/xml"&gt with JavaScript</h1>

  <script id="xml" type="text/xml">
<?xml version="1.0" encoding="utf-8"?>
<foo>
  <bar id="bar">Hello world!</bar>
</foo>
  </script>

</body>

Qual é o problema aqui?

Eu tenho algum texto em um nó, por exemplo:

<xml>&lt;Hello world "&amp;" foo bar&gt;</xml>

Eu gostaria de processar string(/xml)e escapar do JSON para que o resultado fosse algo como:

"<Hello world \"&\" foo bar>"

Como posso fazer isso com o XPath 3.1?

Existe uma função que pode testar (ou retornar) o tipo de .? Por exemplo:

( root(), (), "a", 1, map{}, array{} ) ! unknown:type-of(.)

node
sequence
string
number
map
array

Digamos que você tenha um arquivo que contém N colunas delimitadas por espaços em branco e uma coluna adicional que contém espaços que você deseja manter.

Exemplo com N = 2:

1.1 1.2 data for row1
  2.1   2.2    data   for    row2
?  ?   data   for   row3
 \ * data for   row4

Eu gostaria de produzir:

data for row1
data   for    row2
data   for   row3
data for   row4

No shell você pode fazer isso facilmente com:

while read -r _ _ data
do
    printf "%s\n" "$data"
done < data.txt

Mas com awkisso é meio difícil. Existe um método awkpara dividir apenas as primeiras N colunas?

Eu tenho um conjunto de pares:

inputs = {
    ('id1', 'id2'), ('id1', 'id3'), ('id1', 'id4'),
    ('id2', 'id3'), ('id2', 'id4'),
    ('id3', 'id4'), ('id3', 'id5'),
    ('id4', 'id5'),
    ('id5', 'id6'),
}

E eu gostaria de inverter as combinações de ordem 2, assim:

recombinations = [
    ('id1', 'id2', 'id3', 'id4'),
    ('id3', 'id4', 'id5'),
    ('id5', 'id6'),
]

Consegui fazer isso usando força bruta:

ids = list(sorted( {i for i in itertools.chain(*inputs)} ))

excludes = set()
recombinations = {tuple(i) for i in map(sorted, inputs)}

for i in range(3, len(ids)+1):
    for subset in itertools.combinations(ids, i):
        for j in range(i-1, len(subset)):
            combs = set(itertools.combinations(subset, j))
            if all(tup in recombinations for tup in combs):
                recombinations.add(subset)
                excludes = excludes.union(combs)

for tup in excludes:
    recombinations.remove(tup)

print(recombinations)

{('id1', 'id2', 'id3', 'id4'), ('id3', 'id4', 'id5'), ('id5', 'id6')}

Minha pergunta é: existe uma maneira mais inteligente de fazer isso ou algumas otimizações que eu poderia implementar no código?

Tenho uma lista com um número variável de dicionários, por exemplo:

var = [ {'a': 1, 'b': 2}, {'b': 20, 'a': 10, 'c': 30}, {'c': 300, 'a': 100} ]

Preciso extrair as chaves que são comuns a todos os dictos, fazer uma lista de seus valores associados, criar um novo dict a partir dele e armazená-lo na mesma variável:

O resultado esperado seria:

var = { 'a': [1, 10, 100] }

Posso encontrar a interseção das chaves com:

[k for k in var[0] if all(k in d for d in var[1:])]

Mas como você pode fazer o resto da transformação?

Um colega meu queria executar um programa FORTRAN que pegasse argumentos de arquivos e gerasse sua ordenação (melhor primeiro) de acordo com algum critério biofísico-químico obscuro. O que ele precisava eram dos 10 melhores resultados.

Embora os arquivos não sejam grandes, o problema é que ele recebeu um bash: /home/progs/bin/ardock: Argument list too long, então criei links simbólicos de 6 dígitos para os arquivos e os dei como argumento, o que funcionou ;-)

Agora, se o número de arquivos for realmente muito grande para que o truque acima funcione, o que você pode fazer para obter o melhor de todos eles? Você precisa classificar os arquivos por partes e comparar os melhores com os melhores com algo assim?

#!/bin/bash

best10() { ardock "$@" | head -n 10; }
export -f best10

find . -name '*.dat' -exec bash -c 'best10 "$@"' _ {} + |
xargs bash -c 'best10 "$@"' _ |
xargs bash -c 'best10 "$@"' _ |
xargs bash -c ... | ... | ...

O problema aqui é que o número necessário xargsnão é conhecido antecipadamente, então como você pode fazer um loop?