Encontre a tabela de tradução

17

Dadas duas seqüências, encontre a tabela de conversão ( cifra de substituição ) entre as duas, se a tradução não for possível, a saída será falsa. A resposta deve ser minimizada e criada da esquerda para a direita. O primeiro caractere a ser traduzido entre as palavras deve ser o primeiro na tabela de tradução. Além disso, qualquer letra que não seja traduzida (no mesmo local em que foi originalmente) NÃO deve estar na tabela de tradução.

Provavelmente, mais facilmente definido através de exemplos:

Casos válidos

"bat", "sap" => ["bt","sp"]

Observe a ordem, uma saída de ["tb","ps"]não é válida para este desafio.

"sense", "12n12" => ["se","12"]

Observe como o nnão é traduzido porque é uma relação de 1 para 1.

"rabid", "snail" => ["rabd","snal"]

Observe como o inão é traduzido porque é uma relação de 1 para 1.

"ass", "all" => ["s","l"]

A não está incluído, permanece o mesmo, spode ser mapeado ldevido à correspondência de padrões.

"3121212", "ABLBLBL" => ["312","ABL"]

Corresponde perfeitamente ao padrão.

Falsy Cases

"banana", "angular" => false

(não é do mesmo tamanho, impossível).

"animal", "snails" => false

(cada caractere só pode ser usado UMA VEZ em cada lado da tradução).

"can","cnn" => false

(n é implicitamente usado na tradução, portanto, definir uma tabela de tradução com n-> a seria inválido)

Assim, [aimal,sails]é uma resposta inválida, tornando essa falsidade.

"a1", "22" => false

Veja "advertências", isso é listado como falso. Nesse caso, é porque ae 1não é possível mapear os dois 2. (Cada caractere só pode ser usado UMA VEZ em cada lado da tradução).


Esta resposta parece ser uma boa referência: /codegolf//a/116807/59376

Se você tiver dúvidas sobre a funcionalidade de dois pares de palavras não listados, adie para esta implementação.


Regras de E / S

  • A entrada pode ser como uma matriz de 2 elementos ou como 2 entradas separadas.
  • A saída pode ser delimitada por uma matriz ou nova linha / espaço, semelhante à forma como eu a mostrei.
  • A saída falsa pode ser 0, -1 ou falsa. Erro / Saída vazia também está bem.
  • Você está garantido de que anão será igual be anem bestará vazio.
  • ae bsão seqüências de letras somente para impressão ASCII.

Ressalvas

  • As traduções devem ocorrer da esquerda para a direita, veja o exemplo 1.
  • Você não deve gerar caracteres que permaneçam iguais.
  • Seu programa pode ter apenas duas seqüências de caracteres ae b.
  • Cada caractere só pode ser usado UMA VEZ em cada lado da tradução. Isto é o que faz a tradução do snailsque animalsimpossível.
  • Substituições recursivas não devem ocorrer. Exemplo de substituição recursiva: "a1","22"->[a1,12]onde a é substituído primeiro por 1, os 1s resultantes são substituídos por 2. Isso não está correto, suponha que todas as traduções ocorram independentemente uma da outra, o que significa que isso é falso. Significado: "a1" com tabela de tradução de [a1,12] é avaliado como 12 (não 22)
Urna de polvo mágico
fonte
Rotular essa "tradução" como uma cifra de substituição simples pode ajudar a esclarecer a intenção.
Greg Martin
Matrizes associativas são permitidas como saída? Ele poderia me salvar alguns bytes
Jörg Hülsermann
@ JörgHülserman Não tenho certeza das implicações de permitir isso, talvez faça duas versões para que eu possa ver a diferença? Vou editá-lo se achar que não é prejudicial ao desafio.
Magic Octopus Urn
Olhe para a minha primeira solução cargo de corda e o segundo tem como saída uma matriz associativa
Jörg Hülsermann
@ JörgHülsermann ahhh ... Vejo como você está usando agora, acho que vou proibir isso, nem todos os idiomas suportam estruturas semelhantes a hash.
Magic Octopus Urn

Respostas:

7

JavaScript (ES6), 128 bytes

f=
(s,t)=>!t[s.length]&&[...s].every((c,i)=>n[d=t[i]]==c||d&&!m[c]&&!n[d]&&(n[m[c]=d]=c,c==d||(a+=c,b+=d)),m={},n={},a=b='')&&[a,b]
<div oninput=o.textContent=f(s.value,t.value)><input id=s><input id=t><pre id=o>

Neil
fonte
Não funciona para asse alldeve ser s,l.
Urna Mágica do Polvo
Sim, esse trecho está viajando, também verificado, está tudo bem.
Urna Mágica de Polvo
11
@carusocomputing Era um conflito de nome de variável - está corrigido agora. Me desculpe por isso.
21417 Neil
7

JavaScript (ES6), 108 107 105 106 bytes

Editar : corrigido para suportar entradas como essas "22" / "a1"que devem ser falsas.


Retorna uma 0ou uma matriz de duas cadeias.

f=(a,b,x)=>[...a].some((c,i)=>d[C=b[i]]?d[C]!=c:(d[C]=c)!=C&&(s+=c,t+=C,!C),s=t='',d=[])?0:x||f(b,a,[s,t])

Formatado e comentado

f = (                       // given:
  a,                        // - a = first string
  b,                        // - b = second string
  x                         // - x = reference result from previous iteration,
) =>                        //       or undefined
  [...a].some((c, i) =>     // for each character c at position i in a:
    d[                      //   if we already have a translation
      C = b[i]              //   of the character C at the same position in b,
    ] ?                     //   then:
      d[C] != c             //     return true if it doesn't equal c
    :                       //   else:
      (d[C] = c) != C &&    //     store the translation C -> c in the dictionary
      (                     //     if the characters are different:
        s += c, t += C,     //       append them to the translation strings s and t
        !C                  //       return true if C is undefined
      ),                    //
    s = t = '', d = []      //   initialize s, t and d  
  ) ?                       // if some() returns true:
    0                       //   there was a translation error: abort
  :                         // else:
    x ||                    //   if this is the 2nd iteration, return x
    f(b, a, [s, t])         //   else do a recursive call with (b, a)

Casos de teste

Arnauld
fonte
f('22')('a1')deve ser falso também.
Neil
Espero ter acertado desta vez.
Arnauld
11
É sempre útil quando seu bugfix simplifica para algo mais curto!
194 Neil
7

PHP> = 7.1, 130 bytes

18 bytes salvos por @Titus

for([,$x,$y]=$argv;a&$o=$y[$i];)$o==($p=$x[$i++])?:$k[$c[$p]=$o]=$p;echo$y==strtr($x,$c)&$x==strtr($y,$k)?join($k)." ".join($c):0;

Casos de teste

Expandido

for([,$x,$y]=$argv;a&$o=$y[$i];)
$o==($p=$x[$i++])?:$k[$c[$p]=$o]=$p; # if char string 1 not equal char string 2 make key=char1 value=char2 and key array
echo$y==strtr($x,$c) # boolean replacement string 1 equal to string 2
    &$x==strtr($y,$k) # boolean replacement string 2 equal to string 1
    ?join($k)." ".join($c) # output for true cases
:0; #Output false cases

PHP> = 7.1, 148 bytes

imprime 0 para false Output true como string

for([,$x,$y]=$argv;a&$o=$y[$i];$i++)$x[$i]==$o?:$c[$x[$i]]=$o;echo$y==strtr($x,($f=array_flip)($k=$f($c)))&$x==strtr($y,$k)?join($k)." ".join($c):0;

Casos de teste

Expandido

for([,$x,$y]=$argv;a&$o=$y[$i];$i++)
$x[$i]==$o?:$c[$x[$i]]=$o; # if char string 1 not equal char string 2 set key=char1 value=char2
echo$y==strtr($x,($f=array_flip)($k=$f($c))) # boolean replacement string 1 equal to string 2
&$x==strtr($y,$k) # boolean replacement string 2 equal to string 1
    ?join($k)." ".join($c) # output for true cases
:0; #Output false cases

PHP> = 7.1, 131 bytes

A segunda resposta pode ser reduzida para isso se matrizes associativas forem permitidas

imprime 0 para false Output true como array associativo em vez de string

for([,$x,$y]=$argv;a&$o=$y[$i];$i++)$x[$i]==$o?:$c[$x[$i]]=$o;print_r($y==strtr($x,($f=array_flip)($f($c)))&$x==strtr($y,$k)?$c:0);

Casos de teste

PHP> = 7.1, 227 bytes

imprime 0 para falso

[,$x,$y]=$argv;echo strlen($x)==strlen($y)?strtr($x,$c=array_filter(($f=array_flip)($z=$f(array_combine(($p=str_split)($x),$p($y)))),function($v,$k){return$k!=$v;},1))==$y&$x==strtr($y,$z)?join(array_keys($c))." ".join($c):0:0;

Casos de teste

Expandido

[,$x,$y]=$argv; # 
echo strlen($x)==strlen($y) #compare string lengths
?strtr($x,  # replace function
$c=array_filter( # filter 
($f=array_flip)($z=$f( # # remove doubles like in testcase: a1 => 22
    array_combine(($p=str_split)($x),$p($y))  # replacement array keys string 1 values string 2 
))
    ,function($v,$k){return$k!=$v;},1)) # remove all keys that equal to values in array
    ==$y # boolean replacement string 1 equal to string 2
&$x==strtr($y,$z) # boolean replacement string 2 equal to string 1        
?join(array_keys($c))." ".join($c) # output for true cases
    :0 # Output if replacement from string 1 is not equal to string 2
:0; #Output for different lengths
Jörg Hülsermann
fonte
11
@carusocomputing Obrigado pelo elogio. Eu esqueci um pequeno truque. Eu sei que aqui há muitas pessoas que são melhores, em seguida, me
Jörg Hülsermann
2
Você definitivamente é bom em encontrar soluções +1, mas por array_values()dentro join()é completamente inútil e pode ser descartado.
Christoph
11
Isso falha no a1 22 => falsecaso de teste. Além disso, seu primeiro programa parece não funcionar no testador online.
mbomb007
11
Cale-se. É maravilhoso.
Titus
11
Os flippers podem: Salve 18 bytes ($p=$x[$i])==$o?:$k[$c[$p]=$o]=$p;no loop e $y==strtr($x,$c)no primeiro teste.
Titus
5

Gelatina , 18 bytes

ẠaQ⁼µ€Ạ
z0EÐḟQZẋÇ$

Link monádico sem nome (função de uma entrada) obtendo uma lista, que retorna:
uma lista vazia nos casos de falsey; ou
uma lista contendo duas listas de caracteres nos casos reais.

Experimente online! (o rodapé divide a lista com um espaço para evitar a impressão de uma representação distorcida)
... ou consulte uma suíte de testes .

Quão?

ẠaQ⁼µ€Ạ - Link 1, valid?: mapping list
    µ€  - perform the code to the left for €ach mapping entry
Ạ       -     none of mapping entry falsey? (this & Main's z0 handle unequal input lengths)
  Q     -     deduplicate mapping entry
   ⁼    -     is equal to mapping list? (non-vectorising)
 a      -     and
      Ạ - none falsey (both mapping lists must pass that test)
        - The whole function returns 1 if the mapping list is acceptable, 0 if not

z0EÐḟQZẋÇ$ - Main link: list of strings
z0         - transpose with filler 0 (unequal lengths make pairs containing zeros)
   Ðḟ      - filter discard:
  E        -     all equal? (removes the untranslated character pairs)
     Q     - deduplicate (removes the repeated translation pairs)
      Z    - transpose (list of pairs to pair of lists)
         $ - last two links as a monad:
       ẋ   -     repeat list this many times:
        Ç  -         call last link (1) as a monad
Jonathan Allan
fonte
5

Retina , 194 191 185 229 225 241 bytes

.+
$&;$&
+`^\w(\w*;)\w
$1
^;\w.*|.+;;.*|;;

^((.)*)(.)(.*;(?<-2>.)*(?(2)(?!)))\3
$1$4
+`((.)(.)*)\2((.)*;.*(.)(?<-3>.)*(?(3)(?!)))\6((?<-5>.)*(?(5)(?!)))$
$1$4$7
^(.)*(.)(.)*(\2)?.*;(?<-1>.)*(?(1)(?!))(.)(?<-3>.)*(?(3)(?!))(?(4)(?!\5)|\5).*

Experimente online!

Leva entrada ;separada. A saída também é ;separada. Entradas falsas são significadas por saídas vazias.

Eu sei que isso é dolorosamente detalhado, ainda estou tentando reduzir bytes. A maioria desses bytes é para excluir entradas falsas.

Editar% s

  • Acontece que eu tinha uma falha significativa no meu programa. Está corrigido agora, mas ao custo de mais de 40 bytes.

  • Outro erro foi encontrado onde meu programa não declarou a entrada como a1;22falsa, mas eu consegui manter o programa abaixo de 250 bytes depois de corrigi-lo

Explicação

(uma explicação mais detalhada estará disponível em breve)

Primeiro temos de verificar se os comprimentos das cordas ae bsão os mesmos ou não. Caso contrário, excluímos tudo.

Duplica a entrada para preservá-la enquanto fazemos alguns testes de comprimento.

.+                      Matches everything
$&;$&                   $& indicates the match, so $&;$& will duplicate the match and separate it with a semi-colon

Agora, em um loop, excluímos o primeiro caractere de ae o primeiro caractere de baté que uma das strings fique vazia.

+`                     Repeatedly (until no more substitutions could be made) replace
  ^\w                   A word character (letter or number) at the beginning
     (\w*;)             Capture Group 1: matches any number of word characters and a semicolon
           \w           And a word character after the semi-colon
                       with
$1                      The result of the first capture group

Agora, existem possibilidades para o "espaço padrão".

  • ;;abc Ambas as cordas têm o mesmo comprimento
  • def;;abc a é maior que b
  • ;def;abc b é maior que a

Agora temos que esvaziar a entrada se as seqüências não tiverem o mesmo comprimento (cenários 2 e 3). É isso que essa substituição abaixo faz. Ele remove o texto que corresponde aos cenários 2 e 3.

^;\w.*|.+;;.*|;;

Isso remove caracteres que não são transliterados em strings ae b. abc;1b2=>ac;12

^((.)*)(.)(.*;(?<-2>.)*(?(2)(?!)))\3
$1$4

Depois disso, temos que remover caracteres duplicados. sese;1212=> se;12, mas isso preserva entradas comoaba;123

+`((.)(.)*)\2((.)*;.*(.)(?&lt;-3&gt;.)*(?(3)(?!)))\6((?&lt;-5&gt;.)*(?(5)(?!)))$
$1$4$7

Por fim, excluímos a entrada se houver caracteres duplicados mapeados para caracteres diferentes como aba;123ou a1;22.

^(.)*(.)(.)*(\2)?.*;(?.)*(?(1)(?!))(.)(?.)*(?(3)(?!))(?(4)(?!\5)|\5).*

E, finalmente, remova caracteres duplicados.

Kritixi Lithos
fonte
Usando esses grupos de equilíbrio, eu vejo!
21417 Neil
@ Nee Indeed! Eu também usei o (?(1)(?!))que aprendi com a sua resposta :)
Kritixi Lithos
Gostaria de saber se seria mais curto remover as duplicatas primeiro e depois validar os conjuntos restantes - deve haver apenas uma letra de cada letra em cada lado do ;.
21417 Neil
@ Neil eu encontrei um erro com o meu código experimentando isso. Vou investigar mais de manhã.
precisa saber é o seguinte
4

Geléia , 28 26 bytes

QL$€⁼L€
EÐḟQZK0Ç?
ZÇ0L€E$?

Experimente online!

QL$€⁼L€      Checks validity of mapping
QL$€          number of unique characters in mapping
    ⁼         equals
     L€       number of characters in mapping

EÐḟQZK0Ç?  Writes valid mapping or 0
EÐḟ           filter maps where a = b
   Q          filter duplicate maps
    Z         zip by column [["ac"],["bd"]] => ["ab","cd"]
     K0Ç?   print if valid map, else print 0

ZÇ0L€E$?      main link: takes an array of 2 strings
Z              zip by column: ["ab", "cd"] => [["ac"],["bd"]]
 Ç     ?       print mapping if
   L€E$         all pairs are same length (returns 0 if initial strings were
  0             else 0
layagyasz
fonte
11
Bem-vindo ao PPCG! Como diabos você já conhece Jelly com apenas 21 pontos? Muito impressionante!
Magic Octopus Urn
2
Obrigado. Observou um pouco o site e parecia uma linguagem interessante para aprender.
Layagyasz 17/04
05AB1E é outro fácil e divertido de experimentar.
Urna de polvo mágico
3

Ruby, 133 bytes

->a,b{a.size!=b.size||(m=a.chars.zip b.chars).any?{|i,j|m.any?{|k,l|(i==k)^(j==l)}}?0:m.select{|x,y|x!=y}.uniq.transpose.map(&:join)}

Experimente online!

Mais facilmente:

->a, b{
    # Pair the letters in each string - [AB, AB, AB,...]
    pairs = a.chars.zip(b.chars)

    # If there's any combination of two pairs that share one character but not both,
    # or if the strings have different lengths, then the input's invalid.
    if a.size != b.size || pairs.any?{|i,j| pairs.any? {|k, l| (i==k)!=(j==l) }} 
        return 0 # 0 isn't actually falsy in Ruby, but this challenge allows it anyway
    end
    return pairs.select{|x,y| x != y} # Remove unchanged letters
                .uniq                 # Remove duplicates
                .transpose            # Change [AB, AB, AB] form to [AAA, BBB] form.
                .map(&:join)          # Convert the arrays back into strings
}

Para começar, aqui está uma versão de 84 bytes no Goruby, que é Ruby, mas com uma bandeira de golfe definida ao compilar o intérprete. Entre outras coisas, permite abreviar as chamadas de método para o menor identificador exclusivo.

->a,b{a.sz!=b.sz||(m=a.ch.z b).ay?{|i,j|m.y?{|k,l|(i==k)^(j==l)}}?0:m.rj{|x,y|x==y}.u.tr.m(&:j)}
Tutleman
fonte
Por que não postar uma segunda resposta com a implementação do Goruby? Não é um idioma de golfe aceito?
Urna de polvo mágico
@carusocomputing É totalmente; pareceu-me que não merecia sua própria resposta - é exatamente o mesmo que minha resposta principal, apenas com nomes de métodos abreviados. Talvez se eu encontrar uma maneira de tirar proveito de mais diferenças do Goruby, postarei uma resposta separada.
Tutleman
3

Python 2 , 198,193,189,182,179,175,169, 165 bytes

def f(a,b):
 r=([""]*2,0)[len(a)!=len(b)]
 for u,v in zip(a,b):
	if r:
		q,w=r
		f=q.find(u)
		if u!=v:r=(([q+u,w+v],r)[f>-1 and w[f]==v],0)[f<0 and v in w]
 print r

Experimente online!

  • -4 bytes! obrigado a mbomb007 por sugerir o uso de tab em vez de espaço.

  • modificou o formato de entrada, novamente graças ao mbomb007.

Keerthana Prabhakaran
fonte
O que você quer dizer com isso? pare de fazer edições indesejadas que não agregam valor para responder!
precisa saber é o seguinte
guia salvo em torno de 4 bytes! Obrigado!
precisa saber é o seguinte
E eu fiz seu programa ter cada caso de teste em uma única linha, o que é extremamente útil para qualquer pessoa testando seu programa.
mbomb007
Eu teria melhor se você tivesse mencionado isso no seu comentário de edição!
Keerthana Prabhakaran
3

Python 3,6, 211 185 181 178 bytes

Sai com um erro para resultados falsos.

def f(x,y,d={}):
    for a,b in zip(x,y):1/(a not in d or b==d[a]or len(x)-len(y));d[a]=b;1/([*d.values()].count(b)<2)
    return map(''.join,zip(*[x for x in d.items()if x[0]!=x[1]]))

Isso requer Python 3.6, que você pode executar em um shell aqui .

Você pode testá-lo sem a ordem de saída correta no TIO aqui . (O TIO não possui 3.6).

Ungolfed:

from collections import*
d=OrderedDict()                     # keep order
x,y=input()
if len(x)!=len(y):1/0               # equal lengths
for a,b in zip(x,y):
    if a in d and d[a]!=b:1/0       # no duplicate keys
    else:d[a]=b
    if d.values().count(b)>1:1/0    # no duplicate values
print map(''.join,zip(*[x for x in d.items()if x[0]!=x[1]])) # format, no no-ops

Se apenas a ordem não importasse ...

mbomb007
fonte
Não deveria a1,12retornar em a1,12vez de False? Sob a seção Advertências, diz-se que "a1" com tabela de conversão de [a1,12] é avaliado como 12 .
precisa saber é o seguinte
11
Bem, o programa no seu link TIO retorna False. 1a 21também estaria errado, pois o oeder deve ser preservado.
precisa saber é o seguinte
@fergusq Fixed. Mas observe que você tem um erro de digitação no seu comentário, se esse é o caso de teste a que você se refere, desde que você disse em a1,12vez de a1,22.
mbomb007
Eu te entendi mal. Você se referiu à seção Advertências na edição da sua pergunta, mas a seção Advertências na verdade trata de um caso diferente - não da regra de bijeção. Isso me confundiu.
Fergusq 18/04
Ele lida com uma regra diferente, mas ainda diz que o resultado desse caso de teste é falso, e era isso que importava.
mbomb007
2

Röda , 108 119 bytes

{c=[{_<>_|[[_,_]]|orderedUniq}()]d=[]e=[]c|_|{{d+=a;e+=b}if[a!=b]}for a,b[d,e]if[0,1]|{|n|c|[_[n]]|sort|count|[_2=1]}_}

Experimente online!

Essa é uma função que pega duas listas de caracteres do fluxo e envia duas listas ao fluxo.

Isso poderia ser classificador se eu tivesse permissão para retornar pares.

Explicação (desatualizada):

{
    c=[{
        _<>_|       /* pull two lists and interleave them */
        [[_,_]]|    /* "unflat", create lists from pairs */
        orderedUniq /* remove duplicates */
    }()]            /* c is a list of the pairs */
    d=[]
    e=[]
    c| /* push the pairs to the stream */
    _| /* flat */
    {  /* for each pair (a, b): */
        { /* if a != b (remove "1-to-1 relations"):  */
            d+=a;
            e+=b
        }if[a!=b]
    }for a,b
    /* return d and e if no character is mapped to more than one character */
    [d,e]if c|[_[0]]|sort|count|[_2=1]
}

Aqui está uma solução de sublinhado que não contém variáveis ​​(114 bytes):

{[[{_<>_}()|[[_,_]]|unorderedUniq]]|[[_()|_|[_]if[_1!=_2]],[_1()|_|[_2]if[_1!=_2]]]if[[_1()|_][::2],[_1()|_][1::2]]|[sort(_)|count|[_2=1]]}

Isso é um monte de sublinhados.

fergusq
fonte
O que <>faz?
precisa saber é o seguinte
@KritixiLithos É o operador de intercalação. a() <> b()é o mesmo que interleave([a()], [b()])(ou apenas interleave(a, b), se ae bsão matrizes).
Fergusq 18/04
Isso falha no a1 22 => falsecaso de teste. "todas as traduções ocorrem independentemente uma da outra, o que significa que isso é falso."
Mbomb007
@ mbomb007 Não entendi direito o que você disse? Você quer dizer que tem que ser uma bijeção, ou seja. dois caracteres não devem ser mapeados para um mesmo caractere?
fergusq
Sim. É o que a pergunta diz. ( Cada caractere só pode ser usado UMA VEZ em cada lado da tradução )
mbomb007
1

AWK, 140 bytes

BEGIN{RS="(.)"}RT~/\W/{S=1}RT~/\w/&&S{if(RT!=x=A[++b]){if(B[z=RT]==""){B[z]=x
c=c x
d=d z}a=B[z]!=x?0:a}}!S{A[++a]=RT}END{if(a==b)print c,d}

Uso: Coloque o código FILEentão:

awk -f FILE <<< "string1 string2"

As cadeias de entrada precisam ser separadas por espaço em branco.

A saída está vazia se falharem ou 2 cadeias separadas por um espaço.

Robert Benson
fonte
1

k, 28 bytes

{$[(y?y)~x?x;+?(~=/)#x,'y;]}

Explicação:

{                          } /function that takes in two strings, x and y
 $[         ;            ;]  /if statement (to check if there is a mapping)
         x?x                 /first index of [each letter in x] in x
   (y?y)                     /first index of [each letter in y] in y
        ~                    /make sure they match
                     x,'y    /zip together the two strings
               (~=/)#        /remove equal pairs
              ?              /unique pairs only
             +               /transpose ("unzip", in a way)
zgrep
fonte
1

APL (Dyalog) com AGL , 22 bytes

{≡/⍳⍨¨⍺⍵:↓⍉↑∪⍺(≠é,¨)⍵}

Experimente online!

{...}  função anônima:

 E se…

  ⍺⍵ os argumentos

  ⍳⍨¨ quando auto-indexado (ou seja, as primeiras ocorrências de seus elementos em si)

  ≡/ são equivalentes

: então:

  ⍺(...)⍵  Aplique a seguinte função tácita aos argumentos:

    concatenar elementos correspondentes (erros em comprimentos incompatíveis)

   é filtrar por ( éé apenas a função primitiva/ )

    onde as cordas são diferentes

   exclusivo (remover duplicados)

  ↓⍉↑ transpor lista de pares para par de listas (lit. misturar em tabela, transpor tabela, dividir em listas)

 mais, não faça nada

Adão
fonte
11
aguarda pacientemente a explicação desta resposta : P
Urna de polvo mágico
11
@carusocomputing Estou nele.
Adám 2/17/17
@carusocomputing OK?
Adám 2/17/17
Perdi a resposta, desculpe! ↓⍉↑ainda me deixa um pouco confuso.
Magic Octopus Urn
11
@carusocomputing Talvez isso ajude? Observe que no APL e J, uma matriz não é igual a uma lista de listas.
Adám
0

CJam, 38 bytes

{_:,~={1\/;}:K~z{)\c=!},L|z_{_L|=K}%;}

Entrada e saída são matrizes na pilha.

Esolanging Fruit
fonte
0

PHP (> = 7.1), 165 bytes

for([,$x,$y]=$argv;a&$c=$x[$i];$t[$c]=$d)$z+=($d=$y[$i++])&&$d==($t[$c]??$d);foreach($t as$a=>$b)$a==$b?:$r[$a]=$b;print_r($z<$i|array_unique($r)<$t||a&$y[$i]?0:$t);

imprime 0por outro conjunto associativo falso. Executar -rou testá-lo online .

demolir

for([,$x,$y]=$argv;         # import arguments to $x and $y
    a&$c=$x[$i];            # loop through $x
    $t[$c]=$d)                  # 2. add pair to translation
$z+=                            # 1. increment $z if
    ($d=$y[$i++])&&             # there is a corresponding character in $y and
    $d==($t[$c]??$d);           # it equals a possible previous replacement
                            # remove identities from translation
foreach($t as$a=>$b)$a==$b?:$r[$a]=$b;
print_r(
    $z<$i                   # if not all tests passed
    |array_unique($t)<$t    # or there are duplicates in the translation
    ||a&$y[$i]              # or $y has more characters
    ?0                      # then print 0
    :$r                     # else print translation
);
Titus
fonte
Matrizes associativas como Saída permitida? Você poderia adicionar que ele funciona acima da versão 7.1
Jörg Hülsermann 19/04/19
@ JörgHülsermann Output can be as an array or ..., então eu diria que sim. A versão atual do PHP está implícita em todas as minhas postagens; mas se eu encontrar algo importante para editar, adicionarei a versão.
Titus
Os casos válidos mostram apenas um significado da saída da matriz. Se matrizes associativas também forem permitidas, posso salvar alguns bytes. Se for permitido e array_unique($r)!=$rfor em todos os casos array_unique($r)<$r, votarei sua postagem sozinha para esse truque. No momento estou à procura de uma explicação
Jörg Hülsermann
@ JörgHülsermann array_unique($t)<$t(teve que mudar isso porque canto cnné inválido) funciona, porque a comparação de array (diferente da comparação de string) compara comprimentos antes de qualquer outra coisa.
Titus
O teste canpara cnnme custar 17 Bytes Esqueça a minha sugestão
Jörg Hülsermann