[Question]
  [
*Inspired by [this comment chain](https://codegolf.stackexchange.com/questions/144318/how-many-chapters-do-i-have?noredirect=1&lq=1#comment353719_144318)...*
> 
> I wanna [`enklact`](https://codegolf.stackexchange.com/a/141677/68615) my way out of this challenge but I can't...
> 
> 
> @ETHproductions *to enklact* (v): to implement a lookup table using a subsection consisting of unique elements.
> 
> 
> 
---
Enklacting is a very useful way to compress a lookup table. For example, let's say you had the following list of colors:
```
red
green
blue
yellow
purple
orange
```
If you want to be able to take a color as input and return it's index in this list, there's obviously the straightforward way:
```
["red", "green", "blue", "yellow", "purple", "orange"].index(input())
```
But there's a way we could do this in way less bytes:
```
"rgbypo".index(input()[0])
```
This works because the first (or 0'th) index of each string is unique. This example is obvious, but sometimes it's a little bit harder. What if we wanted to make a lookup table for this list?
```
Sweet Onion Chicken Teriyaki
Oven Roasted Chicken
Turkey Breast
Italian BMT
Tuna
Black Forest Ham
Meatball Marinara
```
In this case, we can't do this:
```
"SOTITBM".index(input()[0])
```
because there are two different inputs that start with a `'T'`, namely "Tuna" and "Turkey". We must look at a different index. If you look at the 4th index of each string, you'll notice that they are all unique. So we can do this...
```
"enklact".index(input()[3])
```
In this case, the *"enklaction string"* is "enklact".
That leads us to today's challenge...
Given a list of strings, return any valid enklaction string. Or in other words, given a list of strings, return any new string where each letter is unique, and the string is formed by joining the i'th letter of each string.
If there is no valid enklaction string, your submission must return an empty string or a consistent falsy value instead. As usual, either functions or full programs are allowed, and the input/output formats are permissive (within reason).
Each string will only contain printable ASCII, and this challenge is case sensitive.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so try to write the shortest program possible in your language of choice!
## Test cases
```
Input:
Programming
Puzzles
Code
Golf
Output (any one of these):
"ozdl"
"gzef"
Input:
the quick
brown fox
jumped over
lazy dogs
Output:
"tbjl"
"hrua"
"eomz"
" wpy"
"qne "
"if o"
"kxvs"
Note that "u dd" and "coog" are not valid.
Input:
Sunday
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Output:
""
Input:
AbC
aBc
bbC
Output:
"Aab"
Input:
@#$%^_
Hello_World
How are you?
Output:
"#eo"
"$lw"
"%l "
"^oa"
Input:
a
ab
ac
Output:
""
```
  
[Answer]
# [Python 2](https://docs.python.org/2/), ~~68~~ ~~67~~ 61 bytes
```
lambda a:`{0:j for j in zip(*a)if len(set(j))==len(j)}`[6::5]
```
[Try it online!](https://tio.run/##RcxBC8IgAAXge79CPGl0iKAOwk5BnYLBBh3WYIa6KU6H08MW/XZL2Or2PXjvDZPvrDlEkT2ipv2TUUBJ89oTBYR1QAFpwCwHtKVYCqC5QSP3SGGcZSko/G6qEyHHOg5OGo8EqmDubOto30vTwh2AeZhnzcfEs2Uc7uDVagFrjDf/TREMo1Pq3OyqMvBx4Z0z8wtlF9zqi5OLCuqDS/4exw8 "Python 2 – Try It Online")
*Improvements*
* From 68 bytes to 67 bytes by [Jo King](https://codegolf.stackexchange.com/users/76162/jo-king)
* From 66 to 65 bytes by [Lynn](https://codegolf.stackexchange.com/users/3852/lynn)
---
**If output would not have to be a string:**
# [Python 3](https://docs.python.org/3/), 49 bytes
```
lambda a:[j for j in zip(*a)if len({*j})==len(j)]
```
[Try it online!](https://tio.run/##TcqxDsIgEADQna@43MQ13dxMmBxcu9cOmEKFwEFoHcT47RgSB7c3vPw6HolPzapbCzreVw36PHuwqYAHx1BdloMmZyEYlu/Bf0ipTk9Ly8XxIa2ccSppKzpGxxuOgNOz1mD2zktaDY54TcHiQtT@pvg10Y/o4ws "Python 3 – Try It Online")
[Answer]
# Python3, 59 bytes
```
lambda l:{len({*d}):''.join(d)for d in zip(*l)}.get(len(l))
```
Returns a string with the enklact, None otherwise
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), ~~43~~ 32 bytes
```
+/^(.).+^\1|^$/ms&m`^.
|""Lm`^.
```
[Try it online!](https://tio.run/##K0otycxLNPz/X1s/TkNPU087LsawJk5FP7dYLTchTo@Lq0ZJyQfE@v8/oCg/vSgxNzczL50roLSqKie1mMs5PyWVyz0/Jw0A "Retina – Try It Online") Edit: Saved 11 bytes thanks to @MartinEnder. Explanation:
```
+
```
Repeat while the input changes...
```
/^(.).+^\1|^$/ms&
```
...only if one line is empty or two lines begin with the same character...
```
m`^.
```
...delete the first character of every line. The repeat therefore stops if either a) all the lines begin with different characters, in which case the condition fails and the input does not get changed, or b) at least one line becomes empty, in which case all the characters eventually get deleted, at which point the input stops changing.
```
|""L`^.
```
Collect the first character of every line. (If there was no solution, the above loop will have deleted everything and there will be nothing to collect.)
[Answer]
# [Haskell](https://www.haskell.org/), 71 bytes
```
f x|elem""x=""|y<-head<$>x,and[filter(==a)y==[a]|a<-y]=y|1<2=f$tail<$>x
```
[Try it online!](https://tio.run/##VYs7DsIwEAV7TrFapQApKaD20lDQpo9cLNgOFv4gJ0hx5LubQEfzZop5D56e2rlaDSxFO@0RF0IsWXQPzUo056XloAZj3azTnogPmWhgWVh0WVIuR3Ei08xs3Teunm0AAhV38Eo2zNCAgQH7FMfE3tswYov9e12dnja7RKU3XKMzKP8vjC0g3357R1k/ "Haskell – Try It Online")
BMO saved 3 bytes with `any null x` → `elem""x`.
Ørjan Johansen saved a byte with `sum[1|b<-y,a==b]<2` → `filter(==a)[y]==[a]`.
## Explanation
```
f x|elem""x=""                      -- Once any of the strings is empty, return "".
   |y<-head<$>x                     -- Otherwise, let y be all the first letters...
   ,and[                 |a<-y]     -- If, for all a in y,
        filter(==a)y==[a]           -- a occurs just once in y:
                               =y   -- return y.
   |1<2=f$tail<$>x                  -- Else, chop off all the first letters and recurse.
```
If throwing an error (`Prelude.head: empty list`) when there's no solution is OK, `|elem""x=""` can be erased for **61 bytes**.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 38 bytes
```
->x,*y{x.zip(*y).find{|z|z==z-[p]|[]}}
```
[Try it online!](https://tio.run/##LcpPT4MwGIDx@/spmjgNEMcSj0acukR3MVmyJTswXF7a8kdLi4U6KPDZcUxPz@/waBO3YxKM88fm1mu7xrd56Xit6ye5ZF1vexsEdh6WUR9GwzDOHnzNkflVKfLaWRxkdzcsXJ8jzbq@5lXdlyQJvUn/z/IgXb/A0rm5pxnqyo2GcaNVqrEocpnCxlgreAUrxTi8KZEA1Bkn3yanXxBrdZIkUQ18mqLkjKgfrkGgbQlTaQWwNZJhC@/qkp3h1dQ9Z/JPu8zoC151PmWLtdET4DleAb5QiM@Fp6vZ9ccR1lwIddwrLRis1Ymg5qRVZgmAgDEgPSOmU5GyXw "Ruby – Try It Online")
Thanks to G B for pointing out a bug.
[Answer]
# [Pyth](https://pyth.readthedocs.io), 6 bytes
```
>1{I#C
```
[Test suite.](https://pyth.herokuapp.com/?code=%3E1%7BI%23C&test_suite=1&test_suite_input=%5B%27Programming%27%2C+%27Puzzles%27%2C+%27Code%27%2C+%27Golf%27%5D%0A%0A%5B%27the+quick%27%2C+%27brown+fox%27%2C+%27jumped+over%27%2C+%27lazy+dogs%27%5D%0A%0A%5B%27Sunday%27%2C+%27Monday%27%2C+%27Tuesday%27%2C+%27Wednesday%27%2C+%27Thursday%27%2C+%27Friday%27%2C+%27Saturday%27%5D%0A%0A%5B%27AbC%27%2C+%27aBc%27%2C+%27bbC%27%5D%0A%0A%5B%27%40%23%24%25%5E_%27%2C+%27Hello_World%27%2C+%27How+are+you%3F%27%5D%0A%0A%5B%27a%27%2C+%27ab%27%2C+%27ac%27%5D%0A&debug=0&input_size=2)
The output is a singleton list, as [allowed by default](https://codegolf.meta.stackexchange.com/a/11884/59487); the list **[ ]** (empty list, falsy) is returned in case the string cannot be *enklactified*.
### Explanation
```
>1{I#C – Full program.
     C – Transpose the input, cropping absences.
    #  – Filter by:
  {I   – Invariant under deduplication.
>1     – Slice to 1. list[:1] in Python.
```
---
**[Pyth](https://pyth.readthedocs.io), 5 bytes**
This would've been valid if crashing would have counted as a falsy value.
```
h{I#C
```
[Test suite.](https://pyth.herokuapp.com/?code=h%7BI%23C&test_suite=1&test_suite_input=%5B%27Programming%27%2C+%27Puzzles%27%2C+%27Code%27%2C+%27Golf%27%5D%0A%0A%5B%27the+quick%27%2C+%27brown+fox%27%2C+%27jumped+over%27%2C+%27lazy+dogs%27%5D%0A%0A%5B%27Sunday%27%2C+%27Monday%27%2C+%27Tuesday%27%2C+%27Wednesday%27%2C+%27Thursday%27%2C+%27Friday%27%2C+%27Saturday%27%5D%0A%0A%5B%27AbC%27%2C+%27aBc%27%2C+%27bbC%27%5D%0A%0A%5B%27%40%23%24%25%5E_%27%2C+%27Hello_World%27%2C+%27How+are+you%3F%27%5D%0A%0A%5B%27a%27%2C+%27ab%27%2C+%27ac%27%5D%0A&debug=0&input_size=2)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 7 bytes
```
z0Q€fZḢ
```
Returns the integer **0** if the strings cannot be enklactified.
[Try it online!](https://tio.run/##Jc8xTsNAEIXh/p1iJaDnBgQiQRqkoESKoCAae8eOw9oD4yzB7qDhANwAWkoUgZAogjiIc5HFTpr5fr1u5uxcFUJ9eLF5ek@ums/X8PfSfL1tHn/Wq/Wq@f5o99/n9lyGMFRJlfI8K1IMfV07LtEXyzgTlwCLGZs7n8U3iFSWhUnkAXOf37I1cs8KR3VlrKQlMPKFpQrnsmXsueycsC12NZ553capZh0jWnjtAsdRH3QSI2pFb2//4HqKQfuETCeizmIgS0PKphJ/BBAoAsX/ "Jelly – Try It Online")
### How it works
```
z0Q€fZḢ  Main link. Argument: A (string array)
z0       Zip/transpose, filling shorter rows with 0.
  Q€     Unique each deduplicate resulting string.
     Z   Zip/transpose, without using a filler.
    f    Filter; keep only string that appear in the results to both sides.
      Ḣ  Head; extract the first string. Returns 0 if the array is empty.
```
[Answer]
# [R](https://www.r-project.org/), ~~116~~ ~~107~~ 95 bytes
**R+pryr**
```
pryr::f(for(i in 1:min(nchar(v)))`if`(anyDuplicated(t<-substr(v,i,i)),0,{cat(t,sep="")
break}))
```
[Try it online!](https://tio.run/##NY3BasMwEETv@gqRkxYUaK8mvbglNBATaP0BWTtrskhem5WcYkq/3VUPvc3whnm65XE@7LdZV62qwQ2TOrYs9rkaWZz0d1T3AIArD1eHsr4tc@QeM91cPuzT0qVcBp49A/gn/12Qyz7R/LLbgemUMPwA/FlcybczCyUHYD6/iLK9CE9iX@/cBxLbkvKKgc3lUdrHhKlo/qlpFw202rrcpGxOGSOj2LppCxE0dcQ@2OOklLJ9x9E0hLnDGG2DyoKKZvsF "R – Try It Online")
**base R**
```
function(v)for(i in 1:min(nchar(v)))`if`(anyDuplicated(t<-substr(v,i,i)),0,{cat(t,sep="")
v=0})
```
[Try it online!](https://tio.run/##NY3BasMwEETv@oolJwkUSK8luTihtFATaP0B2ShrslheG2ntYkq@3VEPPc68YV5atR/327WdJCgPYmfXDskysMDLa89iJdwxldq5C7cXi7KcpjFyQKWb1f02T9esZeDZs3N@538LsuozjYfNxpn5sHu4P4tNhLdPFsrWOfP9Q6RwluKE451DRwINJV6wY3OeS/oaMBfHPzXNlDpaoCo3Wc2HYmQUqOqmEEFTRQwdvA2JssI79qYm1CvGCDUmFkxo1ic "R – Try It Online")
*These two variants saving 9 bytes thanks to [Giuseppe](https://codegolf.stackexchange.com/users/67312/giuseppe).*
### Explanation:
This effectively truncates all stings in the vector `v` to the length of the shortest and iterates through subsequent indexes. Then checks whether there are any duplicates within chosen letters and if not, pastes them together and prints with `cat`. If all indexes return duplicated results, this prints empty string.  
All wraped in an anonymous `pryr` function with `break` to halt the loop, or base R function zeroing the vector to break the loop.
[Answer]
# [Haskell](https://www.haskell.org/), ~~76~~ 74 bytes
```
f t=last$"":(id=<<foldr(zipWith(#))([[]]<$t)t)
x#[s]=[x:s|all(/=x)s]
x#e=e
```
[Try it online!](https://tio.run/##Nci7CoMwAEDRvV8RokMC0u5ipkI7CYKCQ8gQSNTQPCQPsNJ/txbtdA934uEltd62AUSieYg5hCVSglTV4LTwaFVzr@KEMowRpYxVecQRX5aMBkboUoYP1xrdyIID268kcjNcWUCA4XMN0OyVjeAKBgwohY13o@fGKDvCAjZpXbUMu@5OyD1PpwfICgrbZAV/76d2J7okw6FeCvt3NyV/8uHVgZbH5H9kbPsC "Haskell – Try It Online") Returns the last valid lookup string or an empty string if no such string exists.
---
### ~~71~~ 69 bytes
If throwing a consistent exception as falsy value is allowed:
```
f t=head$id=<<foldr(zipWith(#))([[]]<$t)t
x#[s]=[x:s|all(/=x)s]
x#e=e
```
[Try it online!](https://tio.run/##NchNC4MgAIDh@36FWAeF2O4jT4PtFAQFHcSDoC6ZafgBLfbfm6N2eh/ekYeXNGbbFIhklFyUWpC6Vs4Ij1Y9DzqOqMAYUcpYXUYcT0tBAyN0uYYPNwZdyIIDy1cSuU1cW0DAxOcGoNlrG8EZKAwoha13T8@nSdsnrGCb1tXIkHVzQuY8nFGQVRR2yQr@zqdxB/okw65BCvt3PyZ/8O71jo7H5H9kbPsC "Haskell – Try It Online") Throws an `empty list` exception if no string is found, returns the first valid string otherwise.
*-2 bytes thanks to Ørjan Johansen*
[Answer]
# [Stax](https://github.com/tomtheisen/stax), ~~9~~ 8 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
åτIⁿs↓µg
```
[Run and debug it](https://staxlang.xyz/#p=86e749fc7319e667&i=[%22Programming%22,+%22Puzzles%22,+%22Code%22,+%22Golf%22]%0A[%22the+quick%22,+%22brown+fox%22,+%22jumped+over%22,+%22lazy+dogs%22]%0A[%22Sunday%22,+%22Monday%22,+%22Tuesday%22,+%22Wednesday%22,+%22Thursday%22,+%22Friday%22,+%22Saturday%22]%0A[%22AbC%22,+%22aBc%22,+%22bbC%22]%0A[%22%40%23%24%25%5E_%22,+%22Hello_World%22,+%22How+are+you%3F%22]%0A[%22a%22,+%22ab%22,+%22ac%22]&a=1&m=2)
Explanation (unpacked):
```
M{c0-u=}j Full program, implicit input
          e.g. ["Programming", "Puzzles", "Code", "Golf"]
M         Transpose
                ["PPCG", "ruoo", "ozdl", "gzef", "rl\0\0", "ae\0\0", "ms\0\0", "m\0\0\0", "i\0\0\0", "n\0\0\0", "g\0\0\0"]
 {     }j Find first matching element:
            e.g. "PPCG"
  c0-       Copy and remove zero bytes (padding)
                 "PPCG" "PPCG"
     u      Unique
                 "PPCG" "PCG"
      =     Check if equal:
                 1
          First matching here: "ozdl". If none is found, the stack is empty
          Implicit output if anything on stack
```
[Answer]
# [R](https://www.r-project.org/), 127 bytes
```
function(S,s=sapply(S,substring,x<-1:max(nchar(S)+1),x))cat(rbind(s[!apply(s,1,anyDuplicated)&!rowSums(s==""),],"")[1,],sep="")
```
[Try it online!](https://tio.run/##JYuxDoIwFEV3v0IYTBvLwGpgM046lcSBOBRapAk8mvfaCF@PFJZ7Tu7NxbU7F9naBWi9nYBJQSUp54YlamjIo4WvmIssv41qZtD2Cpnk15yLmfNWeYaNBc2oTo4biVwoWO7BDXabjeaXBKefDCMxKss05eIjtqzzjWRcbNaOoVH6acEQ4/wkA2i1nF7TjioYinwbDYdVfcBdHmgjpPIBo6x/ "R – Try It Online")
`sapply` typically returns a `matrix` when all the `length(FUN(X[[i]]))` are equal, except when `length(FUN(X[[i]]))==1`, in which case it returns a `vector`. In order to use the matrix operations, then, we have to `substring` one further than we need to guarantee a `matrix`, which is why `x` extends to `max(nchar(S)+1)`.
We then filter for rows that have no duplicates and no empty strings. Since we can only return a single string, we take the first one, except that when there are no rows that meet the criteria, we would throw an error, so we append an extra row of `""` to the end.
Then we print out the `enklact`ified string or the empty string.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 7 bytes
```
øʒDÙQ}н
```
[Try it online!](https://tio.run/##MzBNTDJM/f//8I5Tk1wOzwysvbD3//9o9ZKMVIXC0szkbHUdBfWkovzyPIW0/AoQJ6s0tyA1RSG/LLUIxM1JrKpUSMlPL1aPBQA "05AB1E – Try It Online")
**Explanation**
```
ø        # Zip the input array
 ʒ   }   # Filter by ...
  DÙQ    # ... an entry is equal to itself deduplicated
      н  # Take the first element
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 27 bytes
```
{([Z] $_).first:{.Set==$_}}
```
[Try it online!](https://tio.run/##RVFdb4IwFH3nV9wgG5psPO5BB3Mz2fayxEQTkxmHBYqghWI/xpDw292tc5o0uee2536c04oK9nAsGril5Y6RWIF/bPvLzxU44cBLcyHVsPVmVPm@E3adYY4VlUqCD0sLYF/Xj1PBN4IURV5uYKoPB0YlTHhC4Y2zNLg7s1yVUdjrPN654EaC1yWk/AfxVhcVTYB/U4EZI4cGEr6R7qVypsuENPDBT2GuqTRxQZPyD80zLU7gVeQmzIjSAsGlwXM0AfISQxRNruuMe87NV4gT3yljPFxwwRKT8RqIoNBw/XRdgQCJgMSYr0aWlXLx78J9AI5B0CKzh7JLlKHAaJVKoCMSFAcCcUYEuksFsBzZfYL3WS4BD6kqHFgq1oBNcJWaJvYAu6HVjikzVp9mBIEX8yIa4ZtEmfthvLbb87f1/6gDb8vzsrPXI6uzjr8 "Perl 6 – Try It Online")
After seeing that the ruby version has been upvoted, I have copied the approach and used character lists, instead of strings. I don't like it.
My older, and more correct submission is as below:
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 38 bytes
Split, zip, check uniqueness, join.
```
{[~] ([Z] @_>>.comb).first:{.Set==$_}}
```
[Try it online!](https://tio.run/##RZBLT8JQEIX3/RUTRAuJsnQBtlZJ1I0JCSQkNlhu22mp3HbgPqylKX8dbxFhdb6TeZzJbFDw@0NewQ0Wa84iBc6h9vcL6PkfC/AC1x1ElIf9QZIJqYb1YIrKcbpB07RDnkKpJDjgWwDbsnyYCEoFy/OsSGGidzuOEsYUI7wST9zbU5etVghbnUVrG@xQUFlAQj@Gv3S@wRjoG4VxnO0qiCmV9nlyqouYVfBOR5lplK3OMS7@aLbS4ggvImtlypQWBs4LnsIxsOcIwnB8Oce76l5/BibxDTmnYE6Cx62jEphAqEg/Xk5gwEJgkfGLkWUlJP6/cOdCtyWoTac04dthtOzUp7/2jrV@01mOrMY6/AI "Perl 6 – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) `-plF`, 56 bytes
Saved 5 bytes thanks to [@Xcali](https://codegolf.stackexchange.com/users/72767/xcali)!
```
map$;[$_].=$F[$_],0..@F}{($_)=grep$.==y///c*!/(.).*\1/,@
```
[Try it online!](https://tio.run/##NY29asMwFEZ3PYUKGuzUlpwhS4rBOGASiDG07pSEcONcWmFZFrL6Y0pfPYo6dDqc7wyfQatW3g9g2NOBnU88Z9Ufk4zzovr9idg5zt8sGsbzfBZCdIsHEfGYL45LkRTev3whOtpoOWq6eZddj5q2aOUMvSTNZ7DnESaH1/9K2g/b40xLi2EnOwdKgqZl3YaigZQKup5Wo8XJ0S0MpEZwF1CK1mClBgu30bhwN/nUqMqn9YpnyyxwLye3Xr86qR6jAb7jOw "Perl 5 – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt) v2.0a0, 7 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
Takes input as an array of ~~character arrays~~ strings, returns ~~an array of characters~~ a string or `undefined`.
```
ÕæÈ¶¸¬â
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=2.0a0&header=tw&code=1ebItris4g&input=IlN3ZWV0IE9uaW9uIENoaWNrZW4gVGVyaXlha2kKT3ZlbiBSb2FzdGVkIENoaWNrZW4KVHVya2V5IEJyZWFzdApJdGFsaWFuIEJNVApUdW5hCkJsYWNrIEZvcmVzdCBIYW0KTWVhdGJhbGwgTWFyaW5hcmEi)
[Answer]
# [Python 3](https://docs.python.org/3/), 75 bytes
```
def f(t):c=[s.pop(0)for s in t];return all(t)and(f(t),c)[len(t)==len({*c})]
```
Operates on character lists instead of strings. Returns False if no valid enklaction string exists.
[Try it online!](https://tio.run/##HY0xD4IwEIX3/orbbI0hJm4YJgdXBzfCUOHAar02xxEB42/H4lveJe979@Ik90CHZWmwhVaLyeui7LMYot6bNjD04AikOjLKwATW@wRZavQK72pTeqR0FcXqn239NdUiOAoUUFbqfXce4coD5gqShKcc1jizMWL64l0v2lEcRBtj/gyONUbJ4cZon0pFdiR6s8kewdG6mtoJXS4cOravl6NOXYZ59tirU2hQnYNvfw)
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 161 bytes
```
f(s,i)char**s;{char**t,a[255],*u=a;for(i=0;memset(a,0,255),u&&~i;i+=!!~i&&u)for(t=s;(u=u?*t++:0)&&~(i=u[i]?i:-1)&&!a[u[i]]++;);while(~i&&(u=*s++))putchar(u[i]);}
```
[Try it online!](https://tio.run/##TY7JTsMwGITveQpHSJG3ogSpl5q0DxLlYBwn@UuW4iUFqvbVjQ0XbjPzzUijdoNS4QkWNflOo1frOlifx2P2PzKwDDELPbYciBqlodSK259wXDYv@33Lqa@l6FeDoS7FrGerHZa85BES7oviAQJYnecPKApPUtHVVmBf@xN1jB1KEjtx7BtoT3DYVdHnskm2ZUwQcR1h0jjN44haxgi5eJde4FQi4h5gcWiWsOAkpBkUR4kjSqPZCLplCEGPEzlWBP2qjVVEZPcQ3KjRhwf1Ht7Mel1Qv36Gs58vukPrpk2Y5PcX6tbB/gA "C (gcc) – Try It Online")
Each character position is tested for duplication and skipped if a duplicate is detected; this is continued until the shortest string ends. It's ASCII only, sadly: DBCS/UTF-8 strings break this function badly!
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 12 bytes
Returns `undefined` for non-enklactic strings.
```
y ·æ_¬n ä¦ e
```
[Try it online!](https://tio.run/##y0osKPn/v1Lh0PbDy@IPrclTOLzk0DKF1P//lQKK8tOLEnNzM/PSuQJKq6pyUou5nPNTUrnc83PSlAA "Japt – Try It Online")
## Explanation:
```
y ·æ_¬n ä¦ e
y             // Split the input at newlines and transpose
  ·           // Join on newlines 
   æ_         // Return the first item that returns truthy when ran through:
     ¬n       //   Sort
        ä¦    //   Reduce with !=
           e  //   All items are truthy (unique)
```
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 54 bytes
```
#&@@Select[PadRight@#,#~FreeQ~0&&Union@#==Sort@#&]&
```
[Try it online!](https://tio.run/##NY69TsMwEID3PEWUQARVJdhRhaFSYUFKSREDgsqNL4nB8cHFprRVuzLyqDxCuDRl8X33@f5q6SqopdO5bIvRSRsnQmRgIHdPqVT3uqyciH9/vofxbkIA0915kjxYjVbEo1GGxL/Jc9KeXgRTr8GJQUracijEYFxJkrkDas7EJgg2UUpYkqxrbctoGKV@vTbQMI1RAYcbNEW0HXIhnxR@eJ2/sV0QLm1Y4Bfzq6/fQYX4CcSZketVqLBs@qbMWyVX7O/wADMPTU@PoOw/zypPB5yQ7iGTzlOH@0lXizE7eZ1365n3UsRHxy9zNrdgDM4fkYzqMlyGkiBcob/sC2XXu@iePNoGwbb9Aw "Wolfram Language (Mathematica) – Try It Online")
Takes a list of list of characters as input, returns a list of characters. Contains U+F3C7, corresponding to "Transpose" operator.
Returns `#1` and throws a bunch of ignorable errors when there is no suitable string.
### Explanation:
```
PadRight@#
```
Pad the input so that each "string" (list of characters) is the same length. This appends integer `0`s (not string `"0"`s). Then transpose.
```
Select[ ... ,#~FreeQ~0&&Union@#==Sort@#&]
```
Select the strings that have no integer `0`s in them and have all unique characters.
```
#&@@
```
Get the first one.
[Answer]
# JavaScript (ES6), 66 bytes
Returns either a string or `undefined` if no solution exists.
```
f=(a,i=0)=>a.every(s=>(o[k+=c=s[i],c]^=1)&&c,o=k=[])?k:c&&f(a,i+1)
```
[Try it online!](https://tio.run/##bY5Bb8IgGIbv@xUk29oSOzOvJug2k22XJSaaeGiqoUArlvI5KLr65zuI7rL0As8XnvflO9ATtczIY/ukgYu@L0lCU0meMZnRsTgJ0yWWzBLI6hFhxGYyT1m@JRMcRSwFUpMsx/N6yqKoDMHRBPcMtAUlxgqqpEyyeGmgMrRppK7iNF66y0UJ62nhP/TXB6gyzjG@@59r9wJ9O8lqLxUGzhqV8OP54Jqj4Aj8cn5S9NIhDpUd7Fg5zWnntS@4wdoJe6WN4PqP13tnbvhu5BVWtHUm4FDxa7HwCn1jYTnPQ87L/cPjdueFT6EU7DZgFA8TnBE1AnXg5oM5GpqLcLDw3v8C "JavaScript (Node.js) – Try It Online")
### Commented
```
f = (           // f = recursive function taking:
  a,            //   a[] = input array
  i = 0         //   i   = pointer
) =>            //
  a.every(s =>  // for each string s in a[]:
    (o[k +=     //   append to the key string k
      c = s[i], //   the character c at position i in s
      c] ^= 1   //   and toggle o[c] (undefined -> 1 -> 0)
    ) && c,     //   additionally, make sure that c is defined
    o = k = []  //   start with o = k = empty array
  ) ?           // every() is true if all characters were distinct and defined:
    k           //   in which case we return k
  :             // else:
    c &&        //   provided that every() didn't fail because of an undefined character,
    f(a, i + 1) //   try again at the next position
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~23~~ 21 bytes
-2 bytes thanks to [@Neil](https://codegolf.stackexchange.com/users/17602/neil)!
```
§ΦＥ⌊ＥθＬι⭆θ§λι⬤ι⁼¹№ιλ⁰
```
[Try it online!](https://tio.run/##NYzBCsIwEET/JacNrKCfUIqKoFDwWHpY2jUNbBObJiL9@RgrnmZ4j5l@pNB7kpyreHEDv@FkJXKAGz1hsm7LGa/sTBzBaq3xHoN15sf/I8FNVSJg8TgnkgUOWPvkYgGiv3Kvc25b1QRvAk3l2yhUTVpX4aW02g9c4uzlobou715CHw "Charcoal – Try It Online")
[Answer]
# [Husk](https://github.com/barbuz/Husk), 9 bytes
```
ḟS=UḞz:∞ø
```
[Try it online!](https://tio.run/##NZBBTsJQEIb3/yleol7CxKiQIC4IRGrYSaZ0aGtf3@C0j1J2uvIUeAvDWk4CF6ktxtX3zfyL@TOJL7Iml@L08b457H@@m@P@a3rzfNzvttenz91h3zSNcoRYmR1C6xk1WysVVl5XliFKLmZgWjGXZuxScaafpIuMnQlY05qyFON1Oz0JFSVH/ykCrxnXpqfc7vFYkk3Jmd4oaBNH6FlaZGYgykVphpRjxFSGZK0ZkaaOlICJSqyU56mLMfHbreUCfYkYD2KXQJmwefPtNYQqlTNL2eDV56u2hKxZYWlbm0jioq3vXUQ1RnJG4LnoOOPI/VmQeD3LQNMOUyq9doL7sA/qLRC2xN3F5dXLHMPuRfOZqI0wlMqQsqnF3wIECkGLXw "Husk – Try It Online")
### Explanation
```
fS=UḞz:∞ø
    Ḟz:∞ø  Transpose the input dropping characters of longer strings
    Ḟ        Fold right
     z:      Zip with prepend
       ∞ø    Infinite list of empty lists
ḟS=U       Find the first string without duplicates, returns an empty string if none
ḟ            Return first value satisfying predicate
  =          Equal
 S U         to itself with duplicates removed
```
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), ~~81~~ 56 bytes
```
m`$
$.=*£¢
N$`.
$.%`
¶
~`(.*?¢)+
L`.{$#1}
A`(.).*\1|£|¢
```
[Try it online!](https://tio.run/##K0otycxLNPz/PzdBhUtFz1br0OJDi7j8VBL0gDzVBK5D27i46hI09LTsDy3S1ObySdCrVlE2rOVyBIpp6mnFGNYcWlxzaNH//wFF@elFibm5mXnpXAGlVVU5qcVczvkpqVzu@TlpAA "Retina – Try It Online")
*-25 bytes thanks to @Neil*
---
Transposing rectangular text in Retina is surprisingly difficult.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~121~~ ~~113~~ 110 bytes
```
i;d;f(s)char**s;{char**_=s,x[255]={0},y[99]={0};for(d=i=0;*_;)d+=x[y[i++]=*(*_++)++]++;d=d?*x?0:f(s):puts(y);}
```
[Try it online!](https://tio.run/##Jc07C4MwGIXhv5IxFwu24KAfwaFDV/cgEhK1gRpLosUL/vbUtNuzvOeoS69UCAY0dNgT9ZSOUg/7Hw33ySJuWVbzPT2SVeT5T9CNDmtueAq0AaIZX8QqDGM1p5g2jJGTjIHmuqRLmRZxu3jPk8crgSMYO6FBGosjpOtVguIhoqc/oiZ7h6PYlQBy7TQ7i9IzC5UbeyeHwdg@VPO2vVof7qNuw2N8dV8 "C (gcc) – Try It Online")
## Ungolfed
```
void enklactify(char *strings[]) {
    int quit = 0;
    while (!quit) {
        char **arg = strings;      // current row
        int exists[255] = {0};     // which characters exist in the column
        char output[99] = {0};     // will hold output string
        int index = 0;             // where to insert in output
        int duplicates = 0;        // have we found any duplicates?
        while (*arg != NULL) {
            char *word = *arg;     // current word
            char first = *word;    // first letter of current word
            if (exists[first])
                duplicates = 1;    // we found a duplicate
            exists[first] = 1;     // mark it as in our string
            output[index] = first; // add it to our output
            index++;
            (*arg)++;              // advances the current word to the next
                                   // character by reference (chops first char)
            arg++;                 // advance to next whole argument
        }
        if (!duplicates) {         // This is a valid solution
            puts(output);
            quit = 1;
        }
        if (exists[0]) {           // We hit the null terminator of one of the
                                   // input strings, so we failed
            quit = 1;
        }
    }
}
```
-3 thanks to ceilingcat
This abuses the ability to just add 1 to a string pointer in C to get the 'tail' of the string. The main byte savers are: 
* `d+=x[y[i++]=*(*_)++]++` which appends the first character of the first string of `_` to `y`, advances the first string of `_` to remove its first character, adds the `x` entry at that character to `d`, and increments said `x` entry
* `q=d?*x:puts(y)` which prints `y` if `d` is non-zero while setting `q` to a non-zero value, or sets `q` to non-zero if the first element of `x` is non-zero (if we were at the end of one of the strings then said element would be non-zero)
Edit: Shaved bytes by switching from while loop to recursive tail call and removing brackets from for loop.
[Answer]
# [Husk](https://github.com/barbuz/Husk), 8 bytes
```
ḟȯ=L¹LUT
```
[Try it online!](https://tio.run/##NZBBTsMwEEWvYgXY9QoISKUCUqtWNKiLqlSTZNqYOB6Y2C3pDi7CEdjClhXXgIuEcdpuPO//P/aMXPi6bKu/t9f29/P95@N8@P01vE/atp3Po@kW0amx1WRVv9BZiVYlyLqBUke9aLwRfUdQO8yPudiJ5xIbFTNKIvrWgdFgVTxKutSClNhAVqoBMdZO3UAl1gjBpWCMGgFrCwzRojePJkxrhqrSdi09E7/bGayF@pSjlGsyq67PFaievewgZsq0tWpFL8KPvnqS9WiDLMrArlE5revuztTbHJowmg6QeKz3NMPcHjkpPB9wwHoPU3CeA4aHrtK@WBBnYbhw8C5PTs8elmLcoDG0nBGbPCjaKmBUDfmLri/8BqThyKLF4h8 "Husk – Try It Online")
Different approach to the [previous Husk answer](https://codegolf.stackexchange.com/a/164245/95126). Gets the longest prefix with all-unique characters from each index position, and then selects the first that is the same length as the number of input strings.
```
ḟ           # first element that satisfies
 ȯ=L¹L      # length (of string) equals length of input (array), of
      U     # longest prefixes of all unique characters of
       T    # transpose of input
```
[Answer]
# Pyth, 13 bytes
```
e+kf{[[email protected]](/cdn-cgi/l/email-protection)
```
[Try it here](https://pyth.herokuapp.com/?code=e%2Bkf%7BIT%40.TQ.t&input=%22Sweet+Onion+Chicken+Teriyaki%22%2C%22Oven+Roasted+Chicken%22%2C%22Turkey+Breast%22%2C%22Italian+BMT%22%2C%22Tuna%22%2C%22Black+Forest+Ham%22%2C%22Meatball+Marinara%22&debug=0)
```
e+kf{[[email protected]](/cdn-cgi/l/email-protection)
           .tQ   Transpose the (implicit) input with padding.
        .TQ      Transpose the input without padding.
       @         Take the strings in both.
   f{IT          Find the ones that have no duplicates.
e+k              Get the last, or an empty string.
```
[Answer]
# [Red](http://www.red-lang.org), 139 bytes
```
func[b][m: length? first b foreach a b[m: min m length? a]repeat n m[c: copy[]foreach a b[append c a/(n)]if c = unique c[return rejoin c]]]
```
[Try it online!](https://tio.run/##VY9BT8MwDIXv/AqrgAQn7pPQgEnABWlik3aowpQmTpuRxp3bMLo/X1xtwHZJPuc9PzuMdnhHm6sLNxlciiYvVF5PIGAsu2oKznPbQQGOGLWpQEMxyrWPUP@ZtGJsUHcgj7mZgKGmz9Vpi24ajBYM6LubeKu8E7yHFP02IZicsUscgXFDEmyUUkPDPnbgIM/mTCXrWkaWGWTztN8HbIVmZFGuFwouUxf//q5C2CZvPkUsmHZRlv8W3qS6QQv0hSxV0PseLJXtWe8iRat7kd/oCMuE7YFWaOMvL6vER3xmf4CFlk@MqOAk8bGYiaafzLiN8Om0h8ur64@1CK8YAq1XxMGOFe1AM0JPaXrm12NSMR4mU8MP "Red – Try It Online")
## Explanation:
Takes the input as a block (list) of strings. Returns the *enklaction* string or `none` otherwise. 
```
f: func[b][
    m: length? first b                   ; the minimal length of the first string  
    foreach a b[m: min m length? a]      ; find the minimal length of all strings
    repeat n m[                          ; limit the search to the minimal length
        c: copy[]                        ; an empty block  
        foreach a b[append c a/(n)]      ; for each string append the current char
        if c = unique c[return rejoin c] ; if all chars are unique, return the block
    ]  
]
```
[Answer]
# [Röda](https://github.com/fergusq/roda), ~~80~~ 77 bytes
```
f a{a|seq 0,#_|try{{|i|a|[_[i:i+1]]|orderedUniq|concat|[_]if[#_1=#a]}_|head}}
```
[Try it online!](https://tio.run/##NclBa4NAEIbhc/ZXDHhJaA/NNZCLhdIeJNDak4h8dUcyaGbJuG0R199uvfT4vo8Fj3XtCDPSyHd6esyaFG2a5yQJqWoqOcnDsa5TMM/G/lPlntqgLeKmtXRV1hzPGeqlSVeGX5b1BlGa3Q50OlMlnjVKnPaH2u26PQ5uWT9@mSNdVILS81XanpVKNpnQi7v8bPUeMEb2/@rKb@t5otx4@@4tYhAo5UW5icLlA9qeXoLxGOkVN1cw4heGgQqYKAx/ "Röda – Try It Online")
*-1 byte thanks to [Cows quack](https://codegolf.stackexchange.com/users/41805/cows-quack)*
Explanation:
```
f a{
  a|         /* Push the strings in a to the stream */
             /* For each string (_): */
  seq 0,#_|     /* Push a range from 0 to the length of _ to the stream */
  try{       /* Ignore errors during the following block */
    {|i|        /* For each i in the stream: */
      a|           /* Push strings in a to the stream */
      [_[i:i+1]]|  /* For each string, push the ith character to the stream */
      orderedUniq| /* Remove duplicate characters */
      concat|      /* Join the characters into a string */
      [_]if        /* Push the string to the stream if */
      [#_1=#a]     /* Its length is the length of a */
    }_|
    head        /* Take the first string in the stream and return it */
  }
}
```
The `try` keyword is used to dismiss errors that occur if `i` is larger than the length of the smallest string in `a`, or there is no answer and `head` causes an error.
[Answer]
# Java 10, 106 bytes
```
a->{for(int i=0;;i++){var r="";for(var s:a)r+=s[i];if(r.length()==r.chars().distinct().count())return r;}}
```
Will give an error instead of returning an empty String if no solution can be found. Input is a character-matrix.
[Try it online.](https://tio.run/##fVNRb9owEH7frzixTUrUNdpzT2wraF37QDsNpD4gVl2SA1yMnZ1tIEX8duYEqDRNVEp0dz7fd9/Zn59pRZfP5WJfaHIOBqTM9h2AMp5lSgXDfRMCDL0oM4MiKeYk48l4ApRizOziHz/nyasC7sFAF/Z0@WU7tZJEFFDdz4jq4iLdrkhAup0ONqkmcFeUykXXjdUE1TSRTLOZ@XmSdruSNX1ckmalcl6Zwke3sMFEmwr7IAYEd7s9HvpXIdex/5HGyqoSlnGU5EC7ZXuYw7PzSUe4xJkwG8x1YKxZa7vGKkilGa2QmXEnc5VWcS920nbSU@1wzezhwShroD9XxYINjFhUTQuFD6sY/bLkPJenLI6CLLiGnnBcxztPWpGB3mAUM4awp6lYwI2VCA@3tMQBk89J63gbkT0JneXyU@xMaLmMM@LP8PKi2WHflow/rJ6erfJzhj8hcsNc7NrA1G7wOSyrSNmuWFDTSw2lnbnzZxBMSTUObGtGgV1jH7k0B280D9I6N6IaM6R4Y9E5C3id95F6BeZ5/@yeb@8/fPz9hLfNZT09WtEl3to1kDDUNnw9W0dIOVLxX/5f6baaaQteNeOOmnmVvDJV8FHghteHRXeUbEweOp4U3waNzo/vZnPl0nYNDiDj@CImEWmTeduPSNciVCcn2lJvj5uHdVTSMrPBZ1UE8tokJiuSFuM05a4gX8yTFuLOlLx5CP5h2ouPpXTfNwVXvpEqb9I3QDtvV38CZ8FYWEXplhCFGrR3nVP/9ix3@78)
**Explanation:**
```
a->{                  // Method with character-matrix parameter and String return-type
  for(int i=0;;i++){  //  Loop `i` upwards
    var r="";         //   Result-String, starting empty
    for(var s:a)      //   Loop over the character-arrays of the input
      r+=s[i];        //    And append every `i`'th character to `r`
    if(r.length()==r.chars().distinct().count())
                      //   If `r` only contains unique characters
      return r;}}     //    Return `r` as result
```
[Answer]
## Clojure, 59 bytes
```
#(for[s(apply map list %):when(=(count(set s))(count %))]s)
```
Returns a list of lists of characters.
]