Given two lists of equal length, find if one of them is a permutation of the other. Output truthy or falsy values, or 1 or 0.
{0,1,2,3,4},{2,4,3,0,1} --> True
{2,4,4,7}{2,7,4,6} --> False
{1},{1} --> True
(.g).(==).g
g=sum.map(65^)
27 bytes
g=sum.map(65^)
a%b=g a==g b
Converts the element counts of each list to base 65 by summing 65^n for each element n, and compares the results. Base 65 works because the lists are guaranteed to have 64 elements max. We're also assuming there are no negative values.
Haskell is an interesting language for this challenge because sorting is locked behind a costly import.
35 bytes
import Data.List
a%b=sort a==sort b
p
Yep, that's just one builtin. Brachylog works in terms of (generally) bidirectional relationships between variables, with two implicit variables conventionally called "input" (?) and "output" (.), but also has a fundamental concept of "declarative failure": here, each of the input and output variables is used to input a list, and the builtin predicate p succeeds in relating them if and only if they're permutations of each other. This is more useful in other contexts, like generating permutations if one of the variables doesn't have a given value, or constraining results of some other computation.
Expects (a)(b) and returns a Boolean value.
a=>b=>a.sort()+""==b.sort()
ᵛS≈
I haven't golfed in forever.
ᵛS≈ # Takes inputs as a list
S # Sort
ᵛ # All elements of the list (both inputs)
≈ # And check if they are equal
-1 thanks to ovs
≍∩⊏∩⊸⍏
∩ ⍏ # get grade of both inputs
∩⊏ ⊸ # index both inputs by grade (sort)
≍ # are they equal?
≍∩⊏∩⊸⍏
\$\endgroup\$
≡⍦
Multiset match: are the two arguments equivalent when treated as multisets? This checks that the elements are both the same and have the same multiplicity.
œ^
Inverted truthy/falsy (with the non vectorizing logical not monad Ṇ in the footer to demonstrate).
œ^ Symmetric multiset difference.
Ṣ€E (monadic pair input) and œ&Ƒ (dyadic) are both non-inverted for 3 bytes (as well as just œ^Ṇ, come to think of it).
+10 bytes due to a bug regarding duplicate items, thanks to chunes.
lambda a,b:sorted(a)==sorted(b)
lambda a,b: # Anonymous lambda function
sorted(a) sorted(b) # Sort a and b
== # Check to see if they're equal
=sort(min(n(sort(A:A)=sort(B:B))))
Put the first list in column A1:A, the second list in B1:B, and the formula in cell C1. Outputs 1 for true and 0 for false.
40 bytes:
=join(",",sort(A:A))=join(",",sort(B:B))
Outputs true or false.
A*B=A∪B==A∩B
Checks if the union and intersections of both lists are equal. A 17-byte solution is possible without Unicode, using the popular sort strategy:
~=sort
A*B=~A==~B
Julia's built-in issetequal would also work if both lists are guaranteed to have equal length.
(a,b)=>a.sort().join``,``==b.sort() (use single backticks)
\$\endgroup\$
Commented
Jul 19 at 22:20
$=>[=sort&sort&]
Sort first list, sort second list, check if they are equal. Each time & is used, it refers to the next argument.
⬤⁺θη⁼№θι№ηι
Try it online! Link is to verbose version of code. Outputs a Charcoal boolean, i.e. - if the two inputs are permutations, nothing if not. Explanation:
θ First input
⁺ Plus
η Second input
⬤ All elements satisfy
№ Count of
ι Current element
θ In first input
⁼ Equals
№ Count of
ι Current element
η In second input
Implicitly print
9 bytes to port @WheatWizard's approach:
⁼ΣＸφθΣＸφη
Try it online! Link is to verbose version of code. Assumes all inputs are non-negative integers and no integer appears more than 999 times and outputs a Charcoal boolean, i.e. - if the two inputs are permutations, nothing if not. Explanation:
φ Predefined variable `1000`
Ｘ Vectorised raised to power
θ First input
Σ Take the sum
⁼ Equals
φ Predefined variable `1000`
Ｘ Vectorised raised to power
η Second input
Σ Take the sum
Implicitly print
Prompts for the two lists as vectors
(⍴n)=+/n[⍒n←⎕]=m[⍒m←⎕]
{1},{1,1} -- > False\$\endgroup\$