Embajadores y traductores

12

Dos embajadores en una conferencia de la ONU quieren hablar entre ellos, pero desafortunadamente cada uno solo habla un idioma, y ​​no son el mismo idioma. Afortunadamente, tienen acceso a varios traductores, cada uno de los cuales entiende y habla algunos idiomas. Su tarea es determinar la cadena más corta de traductores (ya que desea que se pierda lo menos posible en la traducción) que permita a los dos embajadores hablar entre ellos.

Codificación

Entrada: dos idiomas como cadenas minúsculas de 2 letras (idioma de cada embajador) y una lista de listas de idiomas (una lista por traductor disponible)

Alternativamente, puede tomar enteros en lugar de códigos de 2 letras.

Salida: una secuencia de traductores, ya sea por índice o por valor, que es una de las cadenas de traductores más cortas que permite que los dos embajadores se comuniquen. Si no hay una cadena válida de traductores, el comportamiento es indefinido. (Puede bloquearse, generar un valor arbitrario o indicar un error)

Una cadena válida de traductores es aquella en la que el primer traductor habla el idioma de un embajador, el segundo y los siguientes traductores comparten al menos un idioma con el traductor anterior, y el último traductor habla el idioma del otro embajador.

Ejemplos

Usando indexación basada en cero:

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]

Reglas y Suposiciones

  • Se aplican las reglas estándar de E / S (use cualquier formato de E / S conveniente) y las lagunas prohibidas.
  • Puede suponer que hablar y comprender idiomas es perfectamente simétrico y que todas las traducciones posibles entre idiomas son igualmente eficientes.
  • No existe un concepto de lenguajes "lo suficientemente cercanos". No es suficiente usar portugués en un extremo donde se requiere español, por ejemplo.
  • Si hay varias cadenas de traductores más cortas, cualquiera de ellas funcionará.
  • Si los embajadores hablan el mismo idioma, la lista de traductores debe estar vacía.
  • Cuál de los embajadores es el primero no importa; La lista de traductores puede ser directa o inversa.
  • Los embajadores solo hablan un idioma en aras de este desafío
  • Los traductores hablan al menos dos idiomas
  • Los códigos de idioma de 2 letras no necesitan corresponder con idiomas reales
  • Puede suponer que hay una secuencia válida de traductores
  • Si genera la secuencia por valor, incluya el conjunto completo de idiomas disponibles, no solo los relevantes.

¡Feliz golf!

Carne de res
fuente
2
¿Por qué la restricción de E / S a las cadenas de dos caracteres no haría igual a los enteros?
Jonathan Allan
¿Puede la lista de traductores estar en formato csv como:en,fr,sp;en,gr;gr,fr
Quinn
Las reglas de IO estándar de @Quinn dicen que sí.
Beefster
¿Pueden incluirse los embajadores en la salida al principio y al final?
Nick Kennedy
@ NickKennedy Voy a decir que no en eso.
Beefster

Respuestas:

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[]

Pruébalo en línea!

3 bytes thx a ArBo

Devuelve una lista de longitud mínima de los traductores como sets de idiomas, es decir, 'por valor', desde el Tque permite ahablar b.

Chas Brown
fuente
if t not in U and a in tse puede cambiar a if(a in t)>U.count(t)para guardar 4 bytes.
mypetlion
@mypetition - Tuve un pensamiento similar y exprimí otro 2.
Chas Brown
117 mediante *argsnotación
ArBo
@ArBo: agradable; gracias por 3 bytes.
Chas Brown,
3

Jalea , 19 17 bytes

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

Pruébalo en línea!

Un enlace diádico que toma la lista de traductores como argumento izquierdo y la lista de embajadores (cada uno doblemente envuelto en una lista) como argumento correcto. Devuelve una lista de traductores, cada uno de los cuales es una lista de los idiomas que hablan.

¡Gracias a @KevinCruijssen por guardar 2 bytes!

Explicación

Œ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
Nick Kennedy
fuente
Puede guardar 2 bytes eliminando el orden por longitud , ya que el conjunto de potencia + permuraciones ya da como resultado una lista ordenada por longitud.
Kevin Cruijssen
@KevinCruijssen gracias, buen punto!
Nick Kennedy
2

05AB1E , 18 17 bytes

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

Inspirado por la respuesta Jelly de @NickKennedy , ¡así que asegúrate de votarlo!

Produce las listas en sí en lugar de sus índices.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

æ                # 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)
Kevin Cruijssen
fuente
1

JavaScript (ES6),  123  121 bytes

Espera números enteros en lugar de códigos de 2 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)

Pruébalo en línea!

Arnauld
fuente