Ambasciatori e traduttori


12

Due ambasciatori in una conferenza delle Nazioni Unite vogliono parlarsi, ma sfortunatamente ognuno parla solo una lingua e non sono la stessa lingua. Fortunatamente, hanno accesso a numerosi traduttori, ognuno dei quali capisce e parla poche lingue. Il tuo compito è determinare la catena più corta di traduttori (dal momento che vuoi perdere il meno possibile nella traduzione) che consenta ai due ambasciatori di parlare tra loro.

Coding

Input: due lingue come stringhe minuscole di 2 lettere (ogni lingua dell'ambasciatore) e un elenco di elenchi di lingue (un elenco per traduttore disponibile)

In alternativa, puoi inserire numeri interi anziché codici a 2 lettere.

Output: una sequenza di traduttori per indice o valore che rappresenta una delle catene più corte di traduttori che consente ai due ambasciatori di comunicare. Se non esiste una catena valida di traduttori, il comportamento non è definito. (È possibile che si verifichi un arresto anomalo, che generi un valore arbitrario o che indichi un errore)

Una catena di traduttori valida è quella in cui il primo traduttore parla la lingua di un ambasciatore, il secondo e i traduttori successivi condividono almeno una lingua con il traduttore precedente e l'ultimo traduttore parla la lingua dell'altro ambasciatore.

Esempi

Utilizzando l'indicizzazione in base 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]

Regole e presupposti

  • Si applicano le regole IO standard (utilizzare qualsiasi formato I / O conveniente) e le scappatoie vietate.
  • Si può presumere che parlare e comprendere le lingue sia perfettamente simmetrico e che tutte le possibili traduzioni tra le lingue siano ugualmente efficienti.
  • Non esiste un concetto di lingue "abbastanza vicine". Non è abbastanza buono usare il portoghese da un lato dove è richiesto lo spagnolo, per esempio.
  • Se ci sono più catene di traduttori più brevi, ognuna di esse lo farà.
  • Se gli ambasciatori parlano la stessa lingua, l'elenco dei traduttori dovrebbe essere vuoto
  • Quale degli ambasciatori è il primo, non importa; l'elenco dei traduttori può essere in avanti o indietro.
  • Gli ambasciatori parlano solo una lingua per il bene di questa sfida
  • I traduttori parlano almeno due lingue
  • I codici di lingua a 2 lettere non devono corrispondere a lingue reali
  • Puoi presumere che esista una sequenza valida di traduttori
  • Se si emette la sequenza in base al valore, includere l'intero set di lingue disponibili, non solo quelle pertinenti.

Buon golf!


2
Perché la restrizione I / O alle stringhe di due caratteri, gli interi non dovrebbero fare altrettanto?
Jonathan Allan

può l'elenco della lista dei traduttori essere in formato CSV come:en,fr,sp;en,gr;gr,fr
Quinn,

Le regole IO standard di @Quinn dicono di sì.
Beefster

Gli ambasciatori possono essere inclusi nell'output all'inizio e alla fine?
Nick Kennedy,

@NickKennedy Dirò di no su quello.
Beefster

Risposte:


3

Python 2 , 138 126 120 117 113 byte

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

Provalo online!

3 byte grazie ad ArBo

Restituisce un elenco di lunghezza minima dei traduttori come sets di lingue, ovvero "per valore", da Tcui è apossibile parlare b.


if t not in U and a in tpuò essere modificato in if(a in t)>U.count(t)per salvare 4 byte.
mypetlion

@mypetition - Ho avuto un pensiero simile e ne ho spremuto un altro 2.
Chas Brown,

117 usando *argsnotazione
ArBo

@ArBo: Nice; grazie per 3 byte.
Chas Brown,

3

Gelatina , 19 17 byte

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

Provalo online!

Un collegamento diadico che prende l'elenco dei traduttori come argomento di sinistra e l'elenco di ambasciatori (ognuno racchiuso in un elenco) come argomento giusto. Restituisce un elenco di traduttori, ognuno dei quali è un elenco delle lingue che parlano.

Grazie a @KevinCruijssen per aver salvato 2 byte!

Spiegazione

Œ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

È possibile salvare 2 byte rimuovendo l'ordinamento per lunghezza , poiché il powerset + permurazioni risulta già in un elenco ordinato per lunghezza.
Kevin Cruijssen,

@KevinCruijssen grazie, buon punto!
Nick Kennedy

2

05AB1E , 18 17 byte

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

Ispirato da risposta Jelly di @NickKennedy , quindi assicurati di votarlo!

Emette le liste stesse invece dei loro indici.

Provalo online o verifica tutti i casi di test .

Spiegazione:

æ                # 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 byte

Si aspetta numeri interi anziché codici a 2 lettere.

(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)

Provalo online!

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.