Nesta tarefa, consideramos matrizes de números inteiros positivos como este:

3 18 321 17 4 4 51 1 293 17

A entrada compreende um par de tais matrizes de comprimento positivo arbitrário, possivelmente distinto. Determinar se uma ordenação total ≤ _X ⊂ N × N , onde N representa o conjunto dos números inteiros positivos, existe de modo a que ambas as matrizes de entrada estão em ordem em relação à ≤ _X . Observe que (A ≤ _X B ∧ B ≤ _X A) ↔ A = B deve manter, ou seja, dois números são considerados iguais em ≤ _X se e somente se eles tiverem o mesmo número.

Por exemplo, se a entrada fosse o par de matrizes

7 2 1 1 4 12 3
9 8 7 2 5 1

então você deve descobrir se existe uma ordem total ≤ _{X de} tal forma que

7 ≤ _X 2 ≤ _X 1 ≤ _X 1 ≤ _X 4 ≤ _X 12 ≤ _X 3

e

9 ≤ _X 8 ≤ _X 7 ≤ _X 2 ≤ _X 5 ≤ _X 1.

Seu envio pode ser uma sub-rotina ou programa que recebe duas matrizes (como especificado acima) de entrada de uma maneira definida pela implementação, calcula se existe uma ordem total ≤ _X satisfazendo as demandas mencionadas acima e retorna um valor que representa "sim" ou outro valor representando "não". A escolha desses valores é arbitrária, por favor, documente-os.

Você pode supor que as matrizes de entrada não contenham mais que 2 ¹⁵ - 1 elementos cada e que cada um de seus elementos esteja no intervalo de 1 a 2 ¹⁵ - 1, inclusive. Você pode exigir que cada matriz seja finalizada por um sentinela constante fora do intervalo acima mencionado, como 0. Por favor, especifique o que o sentinela é necessário. Você pode exigir os comprimentos das matrizes como entrada adicional se o comprimento não puder ser deduzido das próprias matrizes (por exemplo, em idiomas como C). Além da proibição de brechas padrão, você não tem permissão para usar rotinas de classificação topológica.

Esse desafio é o código de golfe. O envio com a menor quantidade de caracteres vence.

Pyth, 28 22

L.AmqdSdmfhTmxhkbek^b2

Cria uma função yque você pode chamar com uma tupla contendo as duas matrizes. Retorna "Verdadeiro" se houver uma ordem total, "Falso", se não.

Um programa auxiliar que define e chama a função acima com stdin:

L.AmqdSdmfhTmxhkbek^b2y,rw7rw7 

Experimente aqui.

Primeiro lemos as duas matrizes. Em seguida, criaremos todas as combinações de ambas as matrizes. Então, para cada combinação, assumiremos que a primeira matriz é autoritativa e verificaremos se é consistente com a segunda matriz.

GolfScript, 25 bytes

:A{:a;A{.a--.{a?}$=!},},!

Experimente este código online.

Pega uma matriz de duas (ou mais!) Matrizes na pilha; retorna 1 (verdadeiro) se cada par de matrizes de entrada tiver uma ordem total compatível ou 0 (falso) caso contrário.

Ele funciona repetindo todos os pares possíveis de matrizes de entrada (incluindo cada matriz emparelhada), classificando os elementos na primeira matriz de acordo com a posição em que ocorrem pela primeira vez na segunda (ignorando os que não foram encontrados) e verificando que o pedido resultante corresponde ao original.

Embora esse código possa receber um número arbitrário de matrizes de entrada, é importante notar que ele apenas verifica a consistência em pares . Por exemplo, ele retorna true para a entrada [[1 2] [2 3] [3 1]], pois qualquer uma das três matrizes possui um pedido total consistente. Isso é suficiente para o caso de duas entradas, porém, que é tudo o que o desafio exige.

Aqui está uma versão sem golfe com comentários:

:A         # save input to "A", and leave it on the stack to be looped over
{          # run this outer loop for each input array:
  :a;      #   save this array to "a" (and pop it off the stack)
  A{       #   also run this inner loop for each input array:
    .a--   #     remove all elements not in "a" from this array
    .      #     make a copy of the filtered array
    {a?}$  #     sort it by the first location of each element in "a"
    =!     #     check whether the sorted copy differs from the original
  },       #   select those arrays for which there was a difference
},         # select those arrays for which at least one difference was found
!          # return 1 if no differences were found, 0 otherwise

Ps. Seria possível salvar trivialmente um ou dois bytes, exigindo que a entrada fosse fornecida diretamente na variável nomeada Ae / ou alterando o formato de saída para uma matriz vazia para "yes" e uma matriz não vazia para "no" . No entanto, isso me pareceria um pouco extravagante.

J, 36 30 26 bytes

[:*/@,(e.~(-:/:~)@#i.)&>/~

Vamos chamar as duas listas de entrada ae b. A função verifica (com (e.~(-:/:~)@#i.)) se

• aos elementos de s classificados (em relação a a) emb
• aos elementos de s classificados (em relação a a) ema
• bos elementos de s classificados (em relação a b) ema
• bos elementos de s classificados (em relação a b) emb

Entrada é uma lista de dois vetores inteiros.

O resultado é 1se uma ordem existir de 0outra forma. (O tempo de execução é O (n * n).)

Uso:

   f=.[:*/@,(e.~(-:/:~)@#i.)&>/~

   a=.7 2 1 1 4 12 3 [b=.7 2 1 1 4 12 3 1 [c=.9 8 7 2 5 1
   f a;c
1
   f b;c
0

Experimente online aqui.

Ruby, 79

!!gets(p).scan(r=/\d+/){|s|$'[/.*/].scan(r){s!=$&&~/\b#$& .*\b#{s}\b/&&return}}

Espera que a entrada seja um arquivo de duas linhas de números separados por espaço. Retorna truequando existe um pedido, nilse não existir .

Haskell, 98 bytes

import Data.List
a%b=intersect(r a)$r b
r l=map head$group l
c l=nub l==r l
x#y=c x&&c y&&x%y==y%x

Retorna Trueou False. Exemplo de uso: [7,2,1,1,4,12,3] # [9,8,7,2,5,1]-> True.

Como funciona: remova duplicatas consecutivas das listas de entrada (por exemplo:. [1,2,2,3,2] -> [1,2,3,2]Existe uma ordem se as duas listas resultantes não contiverem duplicatas e a interseção de list1 e list2 for igual à interseção de list2 e list1.