Na teoria da informação, um "código de prefixo" é um dicionário em que nenhuma das chaves é o prefixo de outra. Em outras palavras, isso significa que nenhuma das seqüências começa com nenhuma das outras.

Por exemplo, {"9", "55"}é um código de prefixo, mas {"5", "9", "55"}não é.

A maior vantagem disso é que o texto codificado pode ser gravado sem separador entre eles e ainda será decifrável de maneira única. Isso aparece em algoritmos de compactação, como a codificação de Huffman , que sempre gera o código de prefixo ideal.

Sua tarefa é simples: dada uma lista de cadeias, determine se é ou não um código de prefixo válido.

Sua entrada:

• Será uma lista de strings em qualquer formato razoável .

• Contém apenas seqüências ASCII imprimíveis.

• Não conterá nenhuma sequência vazia.

Sua saída será um valor truthy / falsey : Truthy, se for um código de prefixo válido, e falsey, se não for.

Aqui estão alguns casos de teste verdadeiros:

["Hello", "World"]                      
["Code", "Golf", "Is", "Cool"]
["1", "2", "3", "4", "5"]
["This", "test", "case", "is", "true"]          

["111", "010", "000", "1101", "1010", "1000", "0111", "0010", "1011", 
 "0110", "11001", "00110", "10011", "11000", "00111", "10010"]

Aqui estão alguns casos de teste falsos:

["4", "42"]                             
["1", "2", "3", "34"]                   
["This", "test", "case", "is", "false", "t"]
["He", "said", "Hello"]
["0", "00", "00001"]
["Duplicate", "Duplicate", "Keys", "Keys"]

Isso é código-golfe, então as brechas padrão se aplicam e a resposta mais curta em bytes vence.

Pitão, 8 bytes

.AxM.PQ2

Suíte de teste

Pegue todas as 2 permutações de elementos da entrada, mapeie cada uma para o índice de uma sequência na outra (0 para um prefixo) e retorne se todos os resultados são verdadeiros (diferentes de zero).

Haskell, 37 bytes

f l=[x|x<-l,y<-l,zip x x==zip x y]==l

Cada elemento xde lé repetido uma vez para cada elemento do qual é um prefixo, que é exatamente uma vez para uma lista sem prefixos, fornecendo a lista original. A propriedade prefix é verificada fechando as duas listas com x, o que corta os elementos além do comprimento de x.

Java, 128 127 126 125 124 121 bytes

(Obrigado @Kenny Lau, @Maltysen, @Patrick Roberts, @Joba)

Object a(String[]a){for(int i=0,j,l=a.length;i<l;i++)for(j=0;j<l;)if(i!=j&a[j++].startsWith(a[i]))return 1<0;return 1>0;}

Ungolfed

Object a(String[] a) {
    for (int i = 0, j, l = a.length; i < l; i++) 
        for (j = 0; j < l;) 
            if (i != j & a[j++].startsWith(a[i])) return 1<0;
    return 1>0;
}

Saída

[Hello, World]
true

[Code, Golf, Is, Cool]
true

[1, 2, 3, 4, 5]
true

[This, test, case, is, true]
true

[111, 010, 000, 1101, 1010, 1000, 0111, 0010, 1011, 0110, 11001, 00110, 10011, 11000, 00111, 10010]
true

[4, 42]
false

[1, 2, 3, 34]
false

[This, test, case, is, false, t]
false

[He, said, Hello]
false

[0, 00, 00001]
false

[Duplicate, Duplicate, Keys, Keys]
false

Python 2, 48 51 bytes

lambda l:all(1/map(a.find,l).count(0)for a in l)

Para cada elemento ade l, a função a.findlocaliza o índice da primeira ocorrência de ana sequência de entrada, fornecendo -1uma ausência. Então, 0indica um prefixo. Em uma lista sem prefixos, o mapeamento dessa função retorna apenas um 0para asi. A função verifica se esse é o caso de todos a.

51 bytes:

lambda l:[a for a in l for b in l if b<=a<b+'~']==l

Substitua ~por um caractere com código ASCII 128 ou superior.

Para cada elemento aem l, uma cópia é incluído para cada elemento que é um prefixo do mesmo. Para uma lista sem prefixos, o único elemento é aele próprio, portanto, isso fornece a lista original.

CJam, 14 bytes

q~$W%2ew::#0&!

Suíte de teste.

Explicação

q~   e# Read and evaluate input.
$    e# Sort strings. If a prefix exists it will end up directly in front 
     e# of a string which contains it.
W%   e# Reverse list.
2ew  e# Get all consecutive pairs of strings.
::#  e# For each pair, find the first occurrence of the second string in the first.
     e# If a prefix exists that will result in a 0, otherwise in something non-zero.
0&   e# Set intersection with 0, yielding [0] for falsy cases and [] for truthy ones.
!    e# Logical NOT.

JavaScript ES6, 65 43 40 bytes

a=>!/(.*)\1/.test(''+a.sort().join``)
      ^            ^               ^ embedded NUL characters

Minha solução anterior, que tratava matrizes de string de todos os caracteres UTF-8:

a=>!/[^\\]("([^"]*\\")*[^\\])",\1/.test(JSON.stringify(a.sort()))

Consegui evitar, JSON.stringifypois o desafio especifica apenas caracteres ASCII imprimíveis.

Teste

f=a=>!/(\0.*)\1/.test('\0'+a.sort().join`\0`) // since stackexchange removes embedded NUL characters

O.textContent += 'OK: '+
[["Hello", "World"]                      
,["Code", "Golf", "Is", "Cool"]
,["1", "2", "3", "4", "5"]
,["This", "test", "case", "is", "true"]          
,["111", "010", "000", "1101", "1010", "1000", "0111", "0010", "1011", 
 "0110", "11001", "00110", "10011", "11000", "00111", "10010"]
].map(a=>f(a)) 

O.textContent += '\nKO: '+
[["4", "42"]                             
,["1", "2", "3", "34"]                   
,["This", "test", "case", "is", "false", "t"]
,["He", "said", "Hello"]
,["0", "00", "00001"]
,["Duplicate", "Duplicate", "Keys", "Keys"]
].map(a=>f(a))

<pre id=O></pre>

Haskell, 49 bytes

g x=[1|z<-map((and.).zipWith(==))x<*>x,z]==(1<$x)

Isso tem algumas partes:

-- Are two lists (or strings) equal for their first min(length_of_1,length_of_2) elements, i.e. is one the prefix of the other?
(and.).zipWith(==)

-- Check whether one element is the prefix of the other, for all pairs of elements (including equal pairs)
map((and.).zipWith(==))x<*>x

-- This is a list of 1's of length (number of elements that are the prefix of the other)
[1|z<-map((and.).zipWith(==))x<*>x,z]

-- This is the input list, with all the elements replaced with 1's
(1<$x)

Se as duas listas são iguais, um elemento é apenas o prefixo de si mesmo e é válido.

Retina , 19 bytes

A contagem de bytes assume a codificação ISO 8859-1.

O`.+
Mm1`^(.+)¶\1
0

A entrada deve ser separada por avanço de linha. A saída é 0para falsidade e verdade 1.

Experimente online! (Ligeiramente modificado para suportar vários casos de teste separados por espaço.)

Explicação

O`.+

Classifique as linhas na entrada. Se existir um prefixo, ele terminará diretamente na frente de uma string que o contém.

Mm1`^(.+)¶\1

Tente combinar ( M) uma linha completa que também é encontrada no início da próxima linha. A mativa o modo de várias linhas de tal forma que ^inícios de linha partidas e 1garante que só contar no máximo um jogo de tal forma que a saída é 0ou 1.

0

Para trocar 0e 1no resultado, contamos o número de 0s.

Java, 97 bytes

Object a(String[]a){for(String t:a)for(String e:a)if(t!=e&t.startsWith(e))return 1<0;return 1>0;}

Usa a maioria dos truques encontrados na resposta de @ Marv , mas também faz uso da igualdade de referência de loop e string foreach.

Desminificado:

Object a(String[]a){
    for (String t : a)
        for (String e : a)
            if (t != e & t.startsWith(e))
                return 1<0;
    return 1>0;
}

Observe que, como eu disse, isso usa igualdade de referência de string. Isso significa que o código pode se comportar estranhamente devido à internação de String . O código funciona ao usar argumentos passados ​​a partir da linha de comando e também ao usar algo lido na linha de comando. No entanto, se você deseja codificar os valores a serem testados, precisará chamar manualmente o construtor String para forçar a internação a não ocorrer:

System.out.println(a(new String[] {new String("Hello"), new String("World")}));
System.out.println(a(new String[] {new String("Code"), new String("Golf"), new String("Is"), new String("Cool")}));
System.out.println(a(new String[] {new String("1"), new String("2"), new String("3"), new String("4"), new String("5")}));
System.out.println(a(new String[] {new String("This"), new String("test"), new String("case"), new String("is"), new String("true")}));
System.out.println(a(new String[] {new String("111"), new String("010"), new String("000"), new String("1101"), new String("1010"), new String("1000"), new String("0111"), new String("0010"), new String("1011"), new String("0110"), new String("11001"), new String("00110"), new String("10011"), new String("11000"), new String("00111"), new String("10010")}));
System.out.println(a(new String[] {new String("4"), new String("42")}));
System.out.println(a(new String[] {new String("1"), new String("2"), new String("3"), new String("34")}));
System.out.println(a(new String[] {new String("This"), new String("test"), new String("case"), new String("is"), new String("false"), new String("t")}));
System.out.println(a(new String[] {new String("He"), new String("said"), new String("Hello")}));
System.out.println(a(new String[] {new String("0"), new String("00"), new String("00001")}));
System.out.println(a(new String[] {new String("Duplicate"), new String("Duplicate"), new String("Keys"), new String("Keys")}));

PostgreSQL, 186 , 173 bytes

WITH y AS(SELECT * FROM t,LATERAL unnest(c)WITH ORDINALITY s(z,r))
SELECT y.c,EVERY(u.z IS NULL)
FROM y LEFT JOIN y u ON y.i=u.i AND y.r<>u.r AND y.z LIKE u.z||'%' GROUP BY y.c

Saída:

Nenhuma demonstração ao vivo desta vez. http://sqlfiddle.com suporta apenas 9.3 e para executar esta demonstração 9.4 é necessário.

Como funciona:

1. Dividir array de strings com número e nomeá-lo y
2. Obter todos os y
3. LEFT OUTER JOINpara a mesma tabela derivada com base no mesmo i(id), mas com diferentes oridinalque começam com o prefixoy.z LIKE u.z||'%'
4. Agrupe o resultado com base em c(matriz inicial) e use a EVERYfunção de agrupamento. Se cada linha da segunda tabela IS NULLsignifica que não há prefixos.

Entrada se alguém estiver interessado:

CREATE TABLE t(i SERIAL,c text[]);

INSERT INTO t(c)
SELECT '{"Hello", "World"}'::text[]
UNION ALL SELECT  '{"Code", "Golf", "Is", "Cool"}'
UNION ALL SELECT  '{"1", "2", "3", "4", "5"}'
UNION ALL SELECT  '{"This", "test", "case", "is", "true"}'         
UNION ALL SELECT  '{"111", "010", "000", "1101", "1010", "1000", "0111", "0010", "1011","0110", "11001", "00110", "10011", "11000", "00111", "10010"}'
UNION ALL SELECT  '{"4", "42"}'
UNION ALL SELECT  '{"1", "2", "3", "34"}'                   
UNION ALL SELECT  '{"This", "test", "case", "is", "false", "t"}'
UNION ALL SELECT  '{"He", "said", "Hello"}'
UNION ALL SELECT  '{"0", "00", "00001"}'
UNION ALL SELECT  '{"Duplicate", "Duplicate", "Keys", "Keys"}';

EDITAR:

SQL Server 2016+ implementação:

WITH y AS (SELECT *,z=value,r=ROW_NUMBER()OVER(ORDER BY 1/0) FROM #t CROSS APPLY STRING_SPLIT(c,','))
SELECT y.c, IIF(COUNT(u.z)>0,'F','T')
FROM y LEFT JOIN y u ON y.i=u.i AND y.r<>u.r AND y.z LIKE u.z+'%' 
GROUP BY y.c;

LiveDemo

Nota: É uma lista separada por vírgulas, não uma matriz real. Mas a idéia principal é a mesma que em PostgreSQL.

EDIT 2:

Na verdade WITH ORDINALITYpoderia ser substituído:

WITH y AS(SELECT *,ROW_NUMBER()OVER()r FROM t,LATERAL unnest(c)z)
SELECT y.c,EVERY(u.z IS NULL)
FROM y LEFT JOIN y u ON y.i=u.i AND y.r<>u.r AND y.z LIKE u.z||'%' GROUP BY y.c

SqlFiddleDemo

Braquilog , 8 bytes

¬(⊇pa₀ᵈ)

Experimente online!

Saídas através do predicado de sucesso / falha. Leva mais de 60 segundos no último caso de teste de ["111","010","000","1101","1010","1000","0111","0010","1011","0110","11001","00110","10011","11000","00111","10010"] verdade , mas passa rapidamente com um byte adicionado, o que elimina um grande número de possibilidades mais cedo do que o programa ( Ċantes de verificar as permutações em vez de ᵈdepois de verificar as permutações, para limitar o comprimento da sublist para dois).

¬(     )    It cannot be shown that
   p        a permutation of
  ⊇         a sublist of the input
      ᵈ     is a pair of values [A,B] such that
    a₀      A is a prefix of B.

Menos trivial 9-byte variantes do ¬(⊇Ċpa₀ᵈ)que correr em tempo razoável são ¬(⊇o₁a₀ᵈ), ¬(⊇o↔a₀ᵈ)e ¬(⊇oa₀ᵈ¹).

Perl 6 , 24 bytes

{.all.starts-with(.one)}

Experimente online!

Uau, surpreendentemente curto enquanto estiver usando um longo built-in.

Explicação

{                      }  # Anonymous code block taking a list
 .all                     # Do all of the strings
     .starts-with(    )   # Start with
                  .one    # Only one other string (i.e. itself)

Raquete, 70 bytes

(λ(l)(andmap(λ(e)(not(ormap(curryr string-prefix? e)(remv e l))))l))

Python, 58 55 bytes

lambda l:sum(0==a.find(b)for a in l for b in l)==len(l)

JavaScript (ES6), 52 54

Editar 2 bytes salvos thx @Neil

a=>!a.some((w,i)=>a.some((v,j)=>i-j&&!w.indexOf(v)))

Teste

f=a=>!a.some((w,i)=>a.some((v,j)=>i-j&&!w.indexOf(v)))

O.textContent += 'OK: '+
[["Hello", "World"]                      
,["Code", "Golf", "Is", "Cool"]
,["1", "2", "3", "4", "5"]
,["This", "test", "case", "is", "true"]          
,["111", "010", "000", "1101", "1010", "1000", "0111", "0010", "1011", 
 "0110", "11001", "00110", "10011", "11000", "00111", "10010"]
].map(a=>f(a)) 

O.textContent += '\nKO: '+
[["4", "42"]                             
,["1", "2", "3", "34"]                   
,["This", "test", "case", "is", "false", "t"]
,["He", "said", "Hello"]
,["0", "00", "00001"]
,["Duplicate", "Duplicate", "Keys", "Keys"]
].map(a=>f(a))

<pre id=O></pre>

Mathematica 75 69 68 bytes

Loquacious como de costume. Mas Martin B conseguiu reduzir o código em 7 bytes.

Método 1: Armazenando a saída em um Array

(68 bytes)

f@a_:=!Or@@(Join@@Array[a~Drop~{#}~StringStartsQ~a[[#]]&,Length@a])

f@{"111", "010", "000", "1101", "1010", "1000", "0111", "0010", "1011", "0110", "11001", "00110", "10011", "11000", "00111", "10010"}

Verdade

f@{"He", "said", "Hello"}

Falso

Método 2: armazenando a saída em um List

(69 bytes)

f@a_:=!Or@@Flatten[a~Drop~{#}~StringStartsQ~a[[#]]&/@Range@Length@a]

Mathematica, 41 bytes

!Or@@StringStartsQ@@@Reverse@Sort@#~Subsets~{2}&

APL (Dyalog Unicode) , ^{SBCS de} 13 bytes

-2 bytes:

≢=∘≢∘⍸∘.(⊃⍷)⍨

Experimente online!

Explicação:

≢=∘≢∘⍸∘.(⊃⍷)⍨  ⍝ Monadic function train
         ⍷     ⍝ "Find": Convert the right argument into a boolean vector,
               ⍝ where ones correspond to instances of the left argument
        ⊃     ⍝ Take the first item of the above vector (i.e., only prefixes)
     ∘.(  )⍨  ⍝ Commutative outer product: take the above function and apply
              ⍝ it for each possible pair of elements in the input
              ⍝ If the input is a prefix code, the above should have a number of ones
              ⍝ equal to the length of the input (i.e., each item is a prefix of only itself)
              ⍝ To test this...
     ⍸        ⍝ Find the location of all ones in the above
   ≢∘         ⍝ Take the length of the above
≢=∘           ⍝ Compare to the length of the input

J , 17 bytes

#=1#.1#.{.@E.&>/~

Experimente online!

Nota: Na verdade, escrevi isso antes de analisar a resposta da APL, para abordá-la sem viés. Acontece que as abordagens são quase idênticas, o que é interessante. Eu acho que essa é a solução "array thinknig" natural

Tome entrada em caixa porque as seqüências de caracteres são de comprimento desigual.

Crie uma tabela /~de auto-função de cada elemento emparelhado com cada elemento e veja se há uma correspondência no início {.@E.. Isso produzirá uma matriz de 1-0 resultados.

Soma duas vezes 1#.1#.para obter um único número representando "todos os da matriz" e veja se esse número é igual ao comprimento da entrada #=. Se for, as únicas correspondências de prefixo são correspondências próprias, ou seja, temos um código de prefixo.

solução de classificação, 18 bytes

0=1#.2{.@E.&>/\/:~

Tentativa de abordagem diferente. Essa solução classifica e analisa pares adjacentes.

Experimente online!

R , 48 bytes

function(s)sum(outer(s,s,startsWith))==length(s)

Experimente online!

Explicação: outer(s,s,startsWith)gera uma matriz de lógica, verificando se s[i]é um prefixo de s[j]. Se sfor um código de prefixo, haverá exatamente length(s)TRUE elementos no resultado, correspondentes aos elementos diagonais ( s[i]é um prefixo por si só).

Pitão - 13 12 bytes

!ssmm}d._k-Q

Experimente online aqui .

Ruby, 48 bytes

Usa argumentos como entrada e stdout como saída.

p !$*.map{a,*b=$*.rotate!
a.start_with? *b}.any?

Scala, 71 bytes

(s:Seq[String])=>(for{x<-s;y<-s}yield x!=y&&x.startsWith(y)).forall(!_)

Raquete 130 bytes

(define g #t)(for((n(length l)))(for((i(length l))#:unless(= i n))(when(string-prefix?(list-ref l i)(list-ref l n))(set! g #f))))g

Ungolfed:

(define(f l)
  (define g #t)
  (for ((n (length l)))
    (for ((i (length l)) #:unless (= i n))
      (when (string-prefix? (list-ref l i) (list-ref l n))
        (set! g #f))))g)

Teste:

(f [list "Hello" "World"])             
(f [list "Code" "Golf" "Is" "Cool"])
(f [list "1" "2" "3" "4" "5"])
(f [list "This" "test" "case" "is" "true"])          
(f [list "111" "010" "000" "1101" "1010" "1000" "0111" "0010" "1011" 
         "0110" "11001" "00110" "10011" "11000" "00111" "10010"])

(f [list "4" "42"])                             
(f [list "1" "2" "3" "34"])                   
(f [list "This" "test" "case" "is" "false" "t"])
(f [list "He" "said" "Hello"])
(f [list "0" "00" "00001"])
(f [list "Duplicate" "Duplicate" "Keys" "Keys"])

Saída:

#t
#t
#t
#t
#t
#f
#f
#f
#f
#f
#f

C (gcc) , 93 bytes

p(r,e,f,i,x)char**r;{for(f=i=0;i<e;++i)for(x=0;x<e;++x)f|=x!=i&&strstr(r[i],r[x])==r[i];r=f;}

Experimente online!

Simples para loop duplo usando strstr(a,b)==apara verificar os preços. Adicionado principalmente, pois ainda não parece haver uma resposta em C.

05AB1E , 13 bytes

2.ÆDí«ε`Å?}O_

Muito tempo .. Inicialmente, eu tinha uma solução de 9 bytes, mas falhou no caso de teste de chave duplicada.

Experimente online ou verifique todos os casos de teste .

Explicação:

2.Æ             # Get all combinations of two elements from the (implicit) input-list
   Dí           # Duplicate and reverse each pair
     «          # Merge the lists of pairs together
      ε         # Map each pair to:
       `        #  Push both strings to the stack
        Å?      #  And check if the first starts with the second
          }O    # After the map: sum to count all truthy values
            _   # And convert it to truthy if it's 0 or falsey if it's any other integer
                # (which is output implicitly as result)

Japonês , 8 bytes

á2 ËrbÃe

Tente

á2 ËrbÃe     :Implicit input of array
á2           :Permutations of length 2
   Ë         :Map each pair
    r        :  Reduce by
     b       :  Get the index of the second in the first - 0 (falsey) if it's a prefix
      Ã      :End map
       e     :All truthy (-1 or >0)

C # (compilador interativo do Visual C #) , 70 bytes

l=>!l.Any(x=>l.Where((y,i)=>l.IndexOf(x)!=i).Any(z=>z.StartsWith(x)));

Experimente online!

Stax , 6 bytes

å·↑↑¶Ω

Execute e depure

Isso produz um valor diferente de zero para a verdade.

A idéia geral é considerar todos os pares de strings na entrada. Se o índice de substring de um no outro for zero, não será um código de prefixo válido. No stax, o índice de uma substring não existente produz -1. Dessa forma, todos os índices de substring em pares podem ser multiplicados juntos.

Esse é o mesmo algoritmo da solução pyth de isaacg, mas eu o desenvolvi de forma independente.