CareerCup

A recursive solution can be pretty straight forward for this. Basically use the normal recursive way to compute all the permutations of a string but skip the ones where the char would be at its original position.

def derangements_rec chars, remaining, permutation = ""
  return permutation if remaining.empty?

  remaining
    .each_with_index
    .reject { |char, _| chars[permutation.size] == char } # don't allow char at the original position
    .flat_map { |char, index| derangements_rec(chars,
                                               # remaining without the currently processed one
                                               remaining.dup.tap { |r| r.delete_at(index) },
                                               permutation + char) }
end

def derangements input
  chars = input.chars
  derangements_rec chars, chars
end

As we have 3 options for every number and "+" and "-" at the beginning will even each other out we are left with the options that start with "nothing", this means the solution will not always be 0, but actually some positive number. My quick brute force approach looks like this:

def sum_all sum_strings
  sum_strings.inject(0) { |acc, s| acc += eval(s) }
end

def all_sums_rec number_array, sum_strings
  return sum_all(sum_strings) if number_array.empty?

  next_element = number_array.shift

  next_sum_strings = sum_strings.flat_map do |s|
    no = "#{s}#{next_element}"
    plus = "#{s}+#{next_element}"
    minus = "#{s}-#{next_element}"
    [no, plus, minus]
  end

  all_sums_rec number_array, next_sum_strings
end

def all_sums number
  all_sums_rec number.to_s.split(""), [""]
end

This follows basically exactly the problem statement, expanding the number into its elements and building the equations from this expanded number, in the end using "eval" to evaluate what the equation results to and sum them all up.