В теорії інформації «код префікса» - це словник, де жоден з ключів не є префіксом іншого. Іншими словами, це означає, що жодна з рядків не починається з будь-якої іншої.

Наприклад, {"9", "55"}це код префікса, але {"5", "9", "55"}це не так.

Найбільша перевага цього полягає в тому, що закодований текст можна записати без роздільника між ними, і він все одно буде однозначно розшифрований. Це виявляється в алгоритмах стиснення, таких як кодування Хаффмана , який завжди генерує оптимальний код префікса.

Ваше завдання просте: Давши список рядків, визначте, чи це дійсний код префікса чи ні.

Ваш внесок:

• Буде список рядків у будь-якому розумному форматі .

• Міститиме лише рядки для друку ASCII.

• Не буде містити порожніх рядків.

Вашим результатом буде значення truthy / falsey : Truthy, якщо це дійсний код префікса, і Falsey, якщо він не є.

Ось кілька справжніх тестових випадків:

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

Ось кілька помилкових тестових випадків:

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

Це код-гольф, тому застосовуються стандартні лазівки, і найкоротша відповідь у байтах виграє.

Pyth, 8 байт

.AxM.PQ2

Тестовий набір

Візьміть усі перестановки 2-х елементів на вході, картографуйте кожен з індексів одного рядка в іншому (0 за префіксом) і поверніть, чи всі результати є правдоподібними (ненульовими).

Хаскелл, 37 байт

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

Кожен елемент xз lповторюються один раз для кожного елемента , що це префікс, який рівно один раз для приставки вільного списку, даючи початковий список. Властивість префікса перевіряється, стискаючи обидва списки з x, що відрізає елементи за довжиною x.

Ява, 128 127 126 125 124 121 байт

(Дякую @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;}

Безумовно

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;
}

Вихідні дані

[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 байт

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

Для кожного елемента aз l, функція a.findзнаходить індекс першого входження aу вхідному рядку, даючи -1для відсутності. Отже, 0вказує на префікс. У списку без префіксів відображення цієї функції повертає лише одиницю 0для aсебе. Функція перевіряє, що це стосується кожного a.

51 байт:

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

Замініть ~символ символом з кодом ASCII 128 або новішим.

Для кожного елемента aв lдодається копія для кожного елемента, який є його префіксом. Для списку без префіксів єдиний такий елемент є aсамим собою, тому це дає початковий список.

CJam, 14 байт

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

Тестовий набір.

Пояснення

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 байт

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

Моє попереднє рішення, яке обробляло рядкові масиви всіх символів UTF-8:

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

Мені вдалося уникнути, JSON.stringifyоскільки виклик задає лише символи для друку ASCII.

Тест

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 байт

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

Це декілька частин:

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

Якщо два списки рівні, то елемент є лише префіксом самого себе, і він дійсний.

Сітківка , 19 байт

Кількість байтів передбачає кодування ISO 8859-1.

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

Вхід повинен бути розділеним рядком. Вихідний результат - 0для помилкових і 1правдоподібних.

Спробуйте в Інтернеті! (Трохи модифікований для підтримки декількох тестових випадків, розділених простором.)

Пояснення

O`.+

Сортуйте рядки на вході. Якщо префікс існує, він закінчиться прямо перед рядком, який містить його.

Mm1`^(.+)¶\1

Спробуйте зіставити ( M) повний рядок, який також є на початку наступного рядка. mАктивізує багатостроковий режим таким чином, що ^матчі лінії початку і 1гарантує , що ми тільки розраховувати на максимум один матч , так що вихід 0або 1.

0

Для заміни 0і 1в результаті підраховуємо кількість 0s.

Java, 97 байт

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

Використовує більшість хитрощів, знайдених у відповіді @ Marv , але також використовує цикл foreach та рівність опорних рядків.

Без обмежень:

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

Зауважимо, що, як я вже говорив, для цього використовується строкова орієнтирна рівність. Це означає, що код може вести себе дивно через інтернування інтерфейсу . Код працює під час використання аргументів, переданих з командного рядка, а також при використанні чогось прочитаного з командного рядка. Якщо ви хочете твердо кодувати значення для тестування, вам знадобиться вручну викликати конструктор String, щоб змусити інтернування не відбуватися:

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 байти

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

Вихід:

Цього разу немає жодної живої демонстрації. http://sqlfiddle.com підтримує лише 9.3, а для запуску цієї демонстрації потрібно 9.4.

Як це працює:

1. Розділити рядковий масив з числом і назвати його y
2. Отримати все y
3. LEFT OUTER JOINдо тієї ж похідної таблиці, що базується на тому самому i(id), але з різнимoridinal що починається з префіксаy.z LIKE u.z||'%'
4. Групувати результат на основі c(початковий масив) та використовувати EVERYфункцію групування. Якщо кожен рядок з другої таблиці IS NULLозначає, що префіксів немає.

Введіть, якщо хтось зацікавлений:

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"}';

Редагувати:

SQL Server 2016+ реалізація:

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

Примітка: Це розділений комами список, а не реальний масив. Але основна ідея така ж, як і в PostgreSQL.

EDIT 2:

Насправді WITH ORDINALITYможна замінити:

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

Брахілог , 8 байт

¬(⊇pa₀ᵈ)

Спробуйте в Інтернеті!

Результати через предикат успіху / невдачі. Останній тестовий випадок займає більше 60 секунд, ["111","010","000","1101","1010","1000","0111","0010","1011","0110","11001","00110","10011","11000","00111","10010"] але швидко передає його доданим байтом, що виключає велику кількість можливостей раніше, ніж програма робить інакше ( Ċперед тим, як перевірити перестановки, а не ᵈпісля перевірки перестановок, щоб обмежити довжину підпису на два).

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

Менш очевидні 9 байт варіантів , ніж ¬(⊇Ċpa₀ᵈ)які виконуються в розумних термінах є ¬(⊇o₁a₀ᵈ), ¬(⊇o↔a₀ᵈ)і ¬(⊇oa₀ᵈ¹).

Perl 6 , 24 байти

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

Спробуйте в Інтернеті!

Нічого собі, напрочуд короткий під час використання довго вбудованого.

Пояснення

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

Ракетка, 70 байт

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

Пітон, 58 55 байт

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

JavaScript (ES6), 52 54

Відредагуйте 2 байти, збережені thx @Neil

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

Тест

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>

Математика 75 69 68 байт

Вибагливий, як завжди. Але Мартіну Б вдалося зменшити код на 7 байт.

Спосіб 1: Зберігання результатів у Array

(68 байт)

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"}

Правда

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

помилковий

Спосіб 2: Збереження виводу в a List

(69 байт)

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

Математика, 41 байт

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

APL (Dyalog Unicode) , 13 байт ^SBCS

-2 байти:

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

Спробуйте в Інтернеті!

Пояснення:

≢=∘≢∘⍸∘.(⊃⍷)⍨  ⍝ 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 байт

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

Спробуйте в Інтернеті!

Примітка: я насправді писав це, перш ніж дивитись відповідь APL, щоб підійти до нього без упереджень. Виявляється, підходи майже однакові, що цікаво. Я здогадуюсь, це природне рішення "масиву думки"

Візьміть коробку, оскільки струни мають неоднакову довжину.

Створіть таблицю /~самофункцій кожного елемента в парі з кожним елементом і подивіться, чи є відповідність на початку{.@E. . Це дасть матрицю результатів 1-0.

Підсумуйте його вдвічі, 1#.1#.щоб отримати єдине число, що представляє "всі в матриці", і подивіться, чи відповідає це число довжині вводу#= . Якщо це так, єдині збіги префіксів - це власні збіги, тобто у нас є код префікса.

сортувальний розчин, 18 байт

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

Спроба іншого підходу. Це рішення сортує і розглядає сусідні пари.

Спробуйте в Інтернеті!

R , 48 байт

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

Спробуйте в Інтернеті!

Пояснення: outer(s,s,startsWith)виводить матрицю логік, перевіряючи, чи s[i]є префікс s[j]. Якщо sце код префікса, то в результаті є точно length(s)ІСТИНИ елементи, відповідні діагональним елементам ( s[i]є самим префіксом).

Піт - 13 12 байт

!ssmm}d._k-Q

Спробуйте його онлайн тут .

Рубін, 48 байт

Використовує аргументи як введення та stdout як вихід.

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

Скала, 71 байт

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

Ракетка 130 байт

(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

Безголівки:

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

Тестування:

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

Вихід:

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

C (gcc) , 93 байт

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;}

Спробуйте в Інтернеті!

Простий подвійний для циклу за допомогою strstr(a,b)==aперевірки на вигляд. В основному додається, оскільки, здається, ще немає відповіді на С.

05AB1E , 13 байт

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

Занадто довго .. Спочатку у мене було 9-байтове рішення, але воно не вдалося для дублювання ключових тестових випадків.

Спробуйте в Інтернеті або перевірте всі тестові справи .

Пояснення:

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)

Japt , 8 байт

á2 ËrbÃe

Спробуй це

á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 # (Visual C # Interactive Compiler) , 70 байт

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

Спробуйте в Інтернеті!

Стакс , 6 байт

å·↑↑¶Ω

Запустіть і налагоджуйте його

Це створює не нуль для truthy.

Загальна ідея полягає у розгляді кожної пари рядків у вхідних даних. Якщо індекс підрядків одного в іншому колись дорівнює нулю, то це не дійсний код префікса. У stax - індекс неіснуючої підрядки -1. Таким чином, всі парні індекси підрядкових рядків можна множити разом.

Це той самий алгоритм, що і піак-рішення Isaacg, але я розробив його самостійно.