S2T2

Jim Randell 10:37 am on 22 December 2020 Permalink Reply
Tags: by: Sgt. Tellis   

• 

  Jim Randell 10:37 am on 22 December 2020 Permalink | Reply

  Alphametically, we can consider the number to be: ABCDECFG (the 3rd and 6th digits are the same).

  And we can use the [[ SubstitutedExpression ]] solver from the enigma.py library to solve the puzzle.

  The following run file executes in 68ms. (Internal runtime of the generated program is 3.0ms).

  #! python -m enigma -rr
  
  SubstitutedExpression
  
  # number is ABCDECFG (3rd and 6th digits the same)
  --answer="ABCDECFG"
  
  # use digits 0-7, no leading zero
  --digits="0-7"
  --invalid="0,A"
  
  # digit sum is 33
  "A + B + C + D + E + C + F + G == 33"
  
  # difference between sum of first 4 and last 4 is 3
  "abs((A + B + D) - (E + F + G)) == 3"
  
  # first 4 digits are ascending
  "A < B < C < D"
  # but not in arithmetic progression
  "not all_same(B - A, C - B, D - C)"
  
  # last 4 digits have no consecutive pairs
  "abs(C - E) > 1"
  "abs(F - C) > 1"
  "abs(G - F) > 1"
  
  # but exactly three of the digits are consecutive (when ordered)
  --code="check = unpack(lambda a, b, c, d: (c - a == 2) != (d - b == 2))"
  "check(sorted((E, C, F, G)))"
  
  # [optional] just display the answer
  --verbose=A
  

  Solution: The number is 23674605.

  LikeLike

  • 

    Frits 2:34 pm on 22 December 2020 Permalink | Reply

    @Jim: “When out of their correct order, three only of my last four digits have consecutive numerical value”.

    You seem to have interpreted it as “at least three”.

    LikeLike

    • 

      Jim Randell 4:30 pm on 22 December 2020 Permalink | Reply

      @Frits: Yes, this would be a more accurate (and specific) test:

      --code="check = unpack(lambda a, b, c, d: (c - a == 2) != (d - b == 2))"
      "check(sorted((E, C, F, G)))"
      

      It doesn’t change the solutions found. But I’ll update my code.

      LikeLike

• 

  Frits 12:59 pm on 22 December 2020 Permalink | Reply

  “three of the digits are consecutive (in some order)” could (probably) also be achieved by:

  # ^ is bitwise XOR operator
  check = lambda li: li[2] == li[1] + 1 and \
                              ((li[3] == li[2] + 1) ^ (li[1] == li[0] + 1))
  
  "check(sorted([E, C, F, G])"
  

  LikeLike