Python Source Code

import itertools

def solve(N, S):
    """
    Solve a variation of the 'magic gon ring' puzzle:
    We have 2N numbers (1 to 2N) arranged such that:
      - N numbers form the 'outer ring' (outer nodes).
      - N numbers form the 'inner ring' (inner nodes).
    Each 'spoke' consists of one outer node and two adjacent inner nodes
    and must sum to S. For example, for k = 1 to N:

        outer[k] + inner[k] + inner[k+1] == S

    with inner[N+1] wrapping around to inner[1].
    
    Parameters:
        N (int): the number of 'spokes' or the size of each ring.
        S (int): the target sum for each spoke.

    Returns:
        list: A sorted list of valid string representations for all solutions.
    """

    def get_arrangement(outer, inner):
        """
        Given the final outer and inner rings, produce a single string
        representation by concatenating each spoke (outer + two inner).
        Example:
            outer = [o1, o2, ..., oN]
            inner = [i1, i2, ..., iN]
        Then each segment is (o_k, i_k, i_{k+1}), wrapped around for k=N.
        """
        return ''.join(f"{o}{i1}{i2}" for o, i1, i2 in 
                       zip(outer, inner, inner[1:] + inner[:1]))
    
    # All numbers from 1 up to 2N
    nums = range(1, 2*N + 1)

    # A derived sum condition for the outer ring to reduce the search space.
    # This formula (N * (4N + 2 - S)) comes from algebraic manipulation of the
    # sum constraints, ensuring we only choose outer sets that could potentially
    # form valid solutions.
    target_outer_sum = N * (4*N + 2 - S)

    # This list will store all valid solutions (string representations).
    solutions = []
    
    # 1) Find valid combinations of numbers for the outer ring.
    for outer in itertools.combinations(nums, N):
        # Prune quickly if the sum of the chosen 'outer' doesn't match the
        # required sum condition.
        if sum(outer) != target_outer_sum:
            continue
            
        # The remaining numbers become candidates for the inner ring.
        inner_nums = set(nums) - set(outer)
        
        # Common trick in 'magic gon' puzzles: pick the smallest
        # outer number to avoid duplicates / symmetrical solutions.
        first = min(outer)
        remaining_outer = set(outer) - {first}
        
        # 2) Try each possible 'second' number from the inner candidates,
        # and compute a 'third' to complete the first spoke (first + second + third = S).
        for second in inner_nums:
            third = S - first - second
            # If 'third' is not a valid distinct inner number, skip.
            if third not in inner_nums or third == second:
                continue
                
            # 3) Build the rest of the solution recursively.
            def build(curr_outer, curr_inner, avail_outer, avail_inner):
                """
                Recursive function that tries to assign numbers for the
                outer and inner rings so that each spoke sums to S.
                
                Parameters:
                  curr_outer (list): partial assignment of outer numbers so far
                  curr_inner (list): partial assignment of inner numbers so far
                  avail_outer (set): available (unused) outer numbers
                  avail_inner (set): available (unused) inner numbers
                """
                # Base case: if we have used up all inner numbers, check the final spoke.
                if not avail_inner:
                    # We should have exactly one outer number left to complete the ring.
                    # Verify that every spoke (including the final wrap) sums to S.
                    if all(
                        o + i1 + i2 == S 
                        for o, i1, i2 in zip(
                            curr_outer + [list(avail_outer)[0]],
                            curr_inner,
                            curr_inner[1:] + curr_inner[:1]
                        )
                    ):
                        # If valid, transform this arrangement into a string and record it.
                        solutions.append(get_arrangement(
                            curr_outer + [list(avail_outer)[0]],
                            curr_inner
                        ))
                    return
                
                # Otherwise, keep assigning available outer numbers and the corresponding inner number.
                for o in avail_outer:
                    # The needed inner number is the one that completes the sum with
                    # the last assigned inner node and the current outer node.
                    i = S - o - curr_inner[-1]
                    if i in avail_inner:
                        # Recurse with these new assignments removed from availability.
                        build(
                            curr_outer + [o],
                            curr_inner + [i],
                            avail_outer - {o},
                            avail_inner - {i}
                        )
            
            # Initialize the recursion with:
            #   - 'first' as the initial outer
            #   - 'second' and 'third' as the first two inner numbers
            #   - 'remaining_outer' and updated 'inner_nums' 
            build(
                [first],             # curr_outer
                [second, third],     # curr_inner
                remaining_outer,     # avail_outer
                inner_nums - {second, third}  # avail_inner
            )
    
    # Return all sorted solutions (string representations).
    return sorted(solutions)

N, S = map(int, input().split())
print(*solve(N, S), sep='\n')  # Print each valid solution on its own line