Embaixadores e Tradutores


12

Dois embaixadores em uma conferência da ONU querem falar um com o outro, mas infelizmente cada um fala apenas um idioma - e eles não são o mesmo idioma. Felizmente, eles têm acesso a vários tradutores, que cada um entende e fala alguns idiomas. Sua tarefa é determinar a menor cadeia de tradutores (já que você deseja que o mínimo seja perdido na tradução) que permita que os dois embaixadores falem um com o outro.

Codificação

Entrada: dois idiomas como sequências de duas letras em minúsculas (idioma de cada embaixador) e uma lista de listas de idiomas (uma lista por tradutor disponível)

Como alternativa, você pode inserir números inteiros em vez de códigos de duas letras.

Saída: uma sequência de tradutores, por índice ou valor, que é uma das cadeias mais curtas de tradutores que permite que os dois embaixadores se comuniquem. Se não houver uma cadeia válida de tradutores, o comportamento será indefinido. (Você pode travar, gerar qualquer valor arbitrário ou indicar um erro)

Uma cadeia de tradutores válida é aquela em que o primeiro tradutor fala o idioma de um embaixador, o segundo e os tradutores subsequentes compartilham pelo menos um idioma com o tradutor anterior, e o último tradutor fala o idioma do outro embaixador.

Exemplos

Usando indexação baseada em zero:

es, en, [
    [es, en]
] ==> [0]

en, en, [] ==> []

en, jp, [
    [en, zh, ko, de],
    [jp, ko]
] ==> [0, 1]

es, ru, [
    [gu, en, py],
    [po, py, ru],
    [po, es]
] ==> [2, 1]

fr, gu, [
    [it, fr, de, es, po, jp],
    [en, ru, zh, ko],
    [jp, th, en],
    [th, gu]
] ==> [0, 2, 3]

fr, ru, [
    [fr, en],
    [en, ko, jp],
    [en, ru]
] ==> [0, 2]

de, jp, [
    [en, fr],
    [ko, jp, zh],
    [fr, po],
    [es, ko, zh],
    [de, en, th],
    [en, es],
    [de, fr]
] ==> [4, 5, 3, 1]

Regras e premissas

  • Regras padrão de E / S (use qualquer formato de E / S conveniente) e brechas proibidas se aplicam.
  • Você pode assumir que falar e entender idiomas é perfeitamente simétrico e que todas as traduções possíveis entre idiomas são igualmente eficientes.
  • Não há conceito de linguagens "suficientemente próximas". Não é bom o suficiente usar o português em uma extremidade onde o espanhol é necessário, por exemplo.
  • Se houver várias cadeias de tradutores mais curtas, qualquer uma delas funcionará.
  • Se os embaixadores falam o mesmo idioma, a lista de tradutores deve estar vazia
  • Qual dos embaixadores é o primeiro, não importa; a lista de tradutores pode ser encaminhada ou revertida.
  • Os embaixadores falam apenas um idioma para o desafio
  • Os tradutores falam pelo menos dois idiomas
  • Os códigos de idioma de duas letras não precisam corresponder a idiomas reais
  • Você pode assumir que há uma sequência válida de tradutores
  • Se estiver produzindo a sequência por valor, inclua o conjunto completo de idiomas disponíveis, não apenas os relevantes.

Golfe feliz!


2
Por que a restrição de E / S para cadeias de caracteres de dois caracteres não seria igual a números inteiros?
Jonathan Allan

a lista de tradutores pode estar na forma de csv como:en,fr,sp;en,gr;gr,fr
Quinn

As regras de IO padrão da Quinn dizem que sim.
Beefster 13/05/19

Os embaixadores podem ser incluídos na saída no início e no final?
Nick Kennedy

@NickKennedy eu vou dizer não nessa.
Beefster 13/05/19

Respostas:


3

Python 2 , 138 126 120 117 113 bytes

F=lambda a,b,T,*U:a!=b and min([[t]+F(l,b,T,t,*U)for t in T if(t in U)<(a in t)for l in t-{a}]+[2*T],key=len)or[]

Experimente online!

3 bytes de thx para ArBo

Retorna uma lista de tamanho mínimo dos tradutores como sets de idiomas, ou seja, 'por valor', a partir da Tqual você apode conversar b.


if t not in U and a in tpode ser alterado if(a in t)>U.count(t)para salvar 4 bytes.
mypetlion 13/05/19

@mypetition - Eu tinha um pensamento semelhante e espremido para fora outra 2.
Chas Brown

117 usando *argsnotação
ArBo 13/05/19

@ArBo: Nice; thx por 3 bytes.
Chas Brown

3

Geléia , 19 17 bytes

ŒPŒ!€Ẏj@€fƝẠ$ƇḢḊṖ

Experimente online!

Um link diádico que toma a lista de tradutores como o argumento da esquerda e a lista de embaixadores (cada uma envolvida em uma lista) como o argumento da direita. Retorna uma lista de tradutores, cada um dos quais é uma lista dos idiomas que eles falam.

Obrigado a @KevinCruijssen por salvar 2 bytes!

Explicação

ŒPŒ!€Ẏj@€fƝẠ$ƇḢḊṖ | A dyadic link taking a list of translators as left argument and a list of ambassadors (double-wrapped in lists) as right argument

ŒP                | Power set of translators
  Œ!€             | Permutations of each
     Ẏ            | Tighten, i.e. create a single list of all permutations of any length
      j@€         | Join the ambassadors with each set of translators
            $Ƈ    | Filter those where:
           Ạ      |   all
         fƝ       |   the neighbouring pairs have at least one in common
              Ḣ   | Take the first
               Ḋ  | Drop the first ambassador from the start
                Ṗ | Drop the second ambassador from the end

Você pode salvar 2 bytes removendo a classificação por comprimento , pois as permissões do powerset + já resultam em uma lista classificada por comprimento.
Kevin Cruijssen 14/05/19

@KevinCruijssen thanks, good point!
Nick Kennedy

2

05AB1E , 18 17 bytes

怜€`ʒ²š³ªüå€àP}н

Inspirado na resposta de @NickKennedy 's Jelly , por isso não deixe de votar nele!

Produz as próprias listas em vez de seus índices.

Experimente online ou verifique todos os casos de teste .

Explicação:

æ                # Get the powerset of the (implicit) input-list of translators
                 #  i.e. [["ef","gh","bc"],["bc","ab"],["ef","cd","de"]]
                 #   → [[],[["ef","gh","bc"]],[["bc","ab"]],[["ef","gh","bc"],["bc","ab"]],[["ef","cd","de"]],[["ef","gh","bc"],["ef","cd","de"]],[["bc","ab"],["ef","cd","de"]],[["ef","gh","bc"],["bc","ab"],["ef","cd","de"]]]
 €œ              # Get the permutations of each
                 #  → [[[]],[[["ef","gh","bc"]]],[[["bc","ab"]]],[[["ef","gh","bc"],["bc","ab"]],[["bc","ab"],["ef","gh","bc"]]],[[["ef","cd","de"]]],[[["ef","gh","bc"],["ef","cd","de"]],[["ef","cd","de"],["ef","gh","bc"]]],[[["bc","ab"],["ef","cd","de"]],[["ef","cd","de"],["bc","ab"]]],[[["ef","gh","bc"],["bc","ab"],["ef","cd","de"]],[["ef","gh","bc"],["ef","cd","de"],["bc","ab"]],[["bc","ab"],["ef","gh","bc"],["ef","cd","de"]],[["bc","ab"],["ef","cd","de"],["ef","gh","bc"]],[["ef","cd","de"],["ef","gh","bc"],["bc","ab"]],[["ef","cd","de"],["bc","ab"],["ef","gh","bc"]]]]
   €`            # Flatten each one level down (4D list becomes 3D list)
                 #  → [[],[["ef","gh","bc"]],[["bc","ab"]],[["bc","ab"],["ef","gh","bc"]],[["ef","gh","bc"],["bc","ab"]],[["ef","cd","de"]],[["ef","cd","de"],["ef","gh","bc"]],[["ef","gh","bc"],["ef","cd","de"]],[["ef","cd","de"],["bc","ab"]],[["bc","ab"],["ef","cd","de"]],[["ef","cd","de"],["bc","ab"],["ef","gh","bc"]],[["ef","cd","de"],["ef","gh","bc"],["bc","ab"]],[["bc","ab"],["ef","cd","de"],["ef","gh","bc"]],[["bc","ab"],["ef","gh","bc"],["ef","cd","de"]],[["ef","gh","bc"],["ef","cd","de"],["bc","ab"]],[["ef","gh","bc"],["bc","ab"],["ef","cd","de"]]]
     ʒ           # Filter this 3D list by:
      ²š         #  Prepend the second input ambassador
                 #   i.e. [["bc","ab"],["ef","gh","bc"]] and "ab"
                 #    → ["ab",["bc","ab"],["ef","gh","bc"]]
        ³ª       #  Append the third input ambassador
                 #   i.e. ["ab",["bc","ab"],["ef","gh","bc"]] and "ef"
                 #    → ["ab",["bc","ab"],["ef","gh","bc"],"ef"]
          ü      #  For each adjacent pair of translator-lists:
           å     #   Check for each item in the second list, if it's in the first list
                 #    i.e. ["bc","ab"] and ["ef","gh","bc"] → [0,0,1]
            ۈ   #   Then check if any are truthy by leaving the maximum
                 #    → 1
              P  #  And then take the product to check if it's truthy for all pairs
                 #   i.e. ["ab",["bc","ab"],["ef","gh","bc"],"ef"] → [1,1,1] → 1
               # After the filter: only leave the first list of translator-lists
                 #  i.e. [[["bc","ab"],["ef","gh","bc"]],[["bc","ab"],["ef","gh","bc"],["ef","cd","de"]]]
                 #   → [["bc","ab"],["ef","gh","bc"]]
                 # (which is output implicitly as result)

1

JavaScript (ES6),  123  121 bytes

Espera números inteiros em vez de códigos de duas letras.

(a,b,l)=>((B=g=(m,s,i)=>m>>b&1?B<i||(o=s,B=i):l.map(a=>a.map(M=c=>M|=1<<c)|M&m&&m^(M|=m)&&g(M,[...s,a],-~i)))(1<<a,[]),o)

Experimente online!

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.