Integer Keys and Duplicates

Question

Given a non-empty list/vector of positive integers, write a function to check the following conditions in as few bytes as possible.

1. Take the first integer (the key, or k1) and check that the next k1 values have no duplicate values, excluding instances of k1.
2. Take the last integer (the second key, or k2) and check that the k2 values before k2 have no duplicate values, excluding instances of k2.

Note that both keys, k1 and k2, are elements of the list/vector as either key could contain the other.

Also, k1 and/or k2 can be greater than the number of integers within the list, which means you should check every element of the list except for instances of the given key for duplicates.

If both steps return True, return True, else, return False.

NOTE: It should be rather intuitive that searching for duplicates within the first k1+1 elements excluding instances of k1 will exclude the first element, or k1. Some answers I've seen "pop" k1 off the list and do the test on the next k1 elements. Either method yields the same results. This is also true for k2 and it's test.

Test Cases

[5,1,2,5,3,4,3] is TRUE because [k1=5][1,2,5,3,4] has no duplicates, nor does [5,3,4][k2=3] have any duplicates, excluding instances of k3. 

[6,9,12,15,18,19,8,8,3] is FALSE because [k1=6][9,12,15,18,19,8] has no duplicates while [19,8,8][k2=3] has a duplicate.

[100,100,100,100,101,102,3] is TRUE because [k1=100][100,100,100,101,102,3] has no duplicates, and [100,101,102][k2=3] has no duplicates.

[100,100,100,100,101,102,4] is FALSE. [k1=100][100,100,100,101,102,4] has no duplicates, but [100,100,101,102][k2=4] has duplicates.

[6,6,6,6,6,6,6,3,3,3,3] is TRUE. [k1=6][6,6,6,6,6,6] has no duplicates, excluding instances of k1, and [3,3,3][k2=3] has no duplicates, excluding instances of k2.

[1,2] is TRUE (clearly)

[1] is TRUE (clearly)

Answer 1

JavaScript (ES6),  88 75 71  69 bytes

a=>(g=_=>!a.reverse().some(o=(v,i,[k])=>v-k&&o[v]&(o[v]=i<=k)))()&g()

Try it online!

Commented

The function \$g\$ reverses the input array and performs the test with the resulting leading key.

g= _ =>               // g takes no explicit input
  !a.reverse()        // reverse the input array a[]
  .some(o =           // we use the object o to store encountered values
    (v, i,            // for each value v at position i in a[],
           [k]) =>    // with k = leading value:
      v - k &&        //   abort if v is equal to the key
      o[v] &          //   otherwise, test whether o[v] is already set
      (o[v] = i <= k) //   and i is less than or equal to the key,
                      //   in which case o[v] is set
  )                   // end of some()

The main function simply invokes \$g\$ twice.

a => g() & g()

Answer 2

Jelly, 12 bytes

,Uḣ⁹ḟQƑʋḢ$€Ạ

Try it online!

A monadic link taking a list of integers and returning a Jelly Boolean (1 for True, 0 for False).

Explanation

,U            | Pair with reversed list
       ʋḢ$€   | For each pair, do the following as a dyad using the popped head as the right argument y:
  ḣ⁹          | - First y integers
    ḟ         | - Filter out y
     QƑ       | - Check if invariant when uniquified
           Ạ  | All

Answer 3

Python 2, 95 88 75 74 bytes

lambda x:all(A[:A[0]+1].count(a)<2for A in[x,x[::-1]]for a in A if a-A[0])

Try it online!

7 bytes saved thx to Jo King; then 8 more thx to Value Ink; and then 5 more from Jo King; and 1 byte thx to mypetition pointing out an extra space.

Function taking a list of ints; returns False/True.

Answer 4

Charcoal, 31 bytes

∨¬⮌θ⬤Ｅ⟦⮌θθ⟧✂⮌ι⁰⊟ι¹⬤ι∨⁼№ιλ¹⁼λ§ι⁰

Try it online! Link is to verbose version of code. Outputs a Charcoal boolean, which is - for true and nothing for false. Explanation:

∨¬⮌θ

If the reversed list is empty then the result is true. (Don't ask me why I need to reverse the list first... I think the implicit input uses a subtly different data type or something.)

⬤Ｅ⟦⮌θθ⟧

Check the list both backwards and forwards.

✂⮌ι⁰⊟ι¹

Slice the last n elements of the reversed list where n is the last element.

⬤ι∨⁼№ιλ¹⁼λ§ι⁰

Check that each element is either unique or equal to the first element.

Answer 5

Python 3.8 (pre-release), ^{138 \$\cdots\$ 102} 91 bytes

lambda x:all(len(set(t:=[e for e in l[1:l[0]+1]if e-l[0]]))==len(t)for l in[x,x[::-1]]if l)

Try it online!

Saved 11 bytes thanks to @JoKing!!!

Answer 6

Perl 5 -MList::Util=uniq,head -pF,, 71 66 bytes

sub b{(@_=grep$_-@_[0],head$_[0]+1,@_)==uniq@_}$_=b(reverse@F)*b@F

Try it online!

Answer 7

Ruby, 64 56 bytes

Mimics the JavaScript answer in that it takes a helper function and checks the array and its reversed version, but the check for uniqueness is done by taking the subarray based on the key, removing all copies of the key, then checking if the (modified) subarray matches its deduplicated version.

-8 bytes by improving the empty list check, and golfing the deduplication code.

->a{g=->f=0,*a{a=a[0,f]-[f];a&a==a};g[*a]&g[*a.reverse]}

Try it online!

Answer 8

05AB1E, 13 bytes

‚εć©£®KDÙQ}P

Port of @NickKennedy's Jelly answer, so make sure to upvote him as well!

Try it online or verify all test cases.

Explanation:

            # Bifurcate the (implicit) input-string; short for Duplicate & Reverse copy
 ‚           # Pair this reversed input with the duplicated input
  ε          # Map over the inner lists of this pair:
   ć         #  Extract the head; pop and push remainder-list and first item
    ©        #  Store this head in variable `®` (without popping)
     £       #  Leave the first `®` items from the remainder-list
      ®K     #  Remove all `®` (if present)
        DÙ   #  Duplicate this list, and uniquifiy it
          Q  #  And check if it's still the same
  }P         # After the map, check if both were truthy
             # (which is output implicitly as result)

Answer 9

J, ³⁶ 28 bytes

*&({.(-:~.)@-.~}.{.~{.<.#)|.

Try it online!

• *&( )|. Take the original input (implicit in the hook) and its reverse |., and multiply the boolean values * produced by transforming them with the verb in parens &( )

Let's break down the verb in parens...

• }.{.~{.<.# From the beheaded }. input take {.~ this many elements: The smaller of <. the first element {. and the length of the list #
• {.( )@-.~ And from that remove all instances of -.~ the first element of the list {. and @ apply the inner verb in parens...
• (-:~.) Is the list identical to -: its uniq ~.?

Answer 10

R, 72 71 70 bytes

`-`=function(l)!anyDuplicated(head(l,l[1]+1),l[1])
-(l=scan())&-rev(l)

Try it online!

Saved a byte thanks to Sumner18.

Answer 11

Husk, 13 bytes

S¤&ΓȯS=uΣSx↑↔

Try it online! The function does the k1 test for the both the list and its reverse.