0274EasyDivide and ConquerBit Manipulation

Punch Card Fed Backwards

Tracked in this browser only

Trains the technique from

This is an original problem, written from a brief that listed the technique, the difficulty, the topics, the function shape and the input bounds — none of that problem's wording, examples, hints or editorials. The link is there so you can map your practice onto the standard set.

Same function shape, different story and different numbers.

A jacquard loom is driven by cards carrying a row of exactly 32 punch positions, numbered 0 through 31. A card is handed to you as the integer card: position i is punched precisely when bit i of card is 1, with position 0 the least significant bit. Positions above the highest punched one are simply unpunched, and they are still part of the row.

An operator threads one card in end for end. Return the integer that encodes the row of 32 positions turned around, so that position i of the answer is punched precisely when position 31 - i of card is punched.

Position 0 of card is always unpunched, so position 31 of the answer is always unpunched too and the answer fits in a signed 32-bit integer.

Examples

Example 1

Input: card = 6
Output: 1610612736

Positions 1 and 2 are punched and the other 30 are not. Turning the row around moves them to positions 30 and 29, and 2^30 + 2^29 is 1610612736.

Example 2

Input: card = 2147483646
Output: 2147483646

Positions 1 through 30 are punched while positions 0 and 31 are not. Turning the row around sends position 1 to position 30 and position 30 to position 1, so the same positions end up punched and the integer is unchanged.

Example 3

Input: card = 4
Output: 536870912

Only position 2 is punched, and turning the row around sends it to position 29, giving 2^29.

Constraints

0 <= card <= 2^31 - 2
card is even.

The signature

The editor is preloaded with this. It matches the parent problem's shape, so a solution that works here transfers to a judge unchanged.

Python

def reversed_punch_card(card: int) -> int:

Java

public int reversedPunchCard(int card)

The intended approach

Time O(1), 32 iterations regardless of inputSpace O(1)

Run the loop a fixed 32 times rather than until the card runs out of punches. Each round shifts the answer up by one, drops in the current lowest position of the card, and shifts the card down by one. Because the count is fixed at the row width, unpunched high positions are carried along and every punch ends up mirrored about the middle of the row.

Pythonentry point: reversed_punch_card

def reversed_punch_card(card):
    # Peel the lowest position off the card and push it onto the top of the
    # answer, exactly 32 times, so a leading run of unpunched positions still
    # gets its shifts and lands where it belongs.
    # Time: O(1), a fixed 32 iterations.  Space: O(1).
    out = 0
    for _ in range(32):
        out = (out << 1) | (card & 1)
        card >>= 1
    return out

The obvious version

Render the card as a 32-character zero-padded binary string, reverse the string, and read it back as an integer.

This is not filler. It was written independently of the fast solution and the two were run against thousands of random inputs to confirm they agree — which is how the answer above is known to be right. Read it when the intended approach feels like a rabbit pulled out of a hat.

Python

def bf_reversed_punch_card(card):
    row = format(card, '032b')
    return int(row[::-1], 2)

How this problem was checked

Reference solution executed against 8 test cases — 8 passed
3 worked examples confirmed by running the code
0 eight-word sequences shared with the parent problem's text
Agrees with an independent brute-force implementation on random inputs
Test set proven to catch deliberately broken solutions
Reviewed by a separate quality pass
Function arity matches the parent problem's

Create a free account to unlock the solution

See the step-by-step animation, the intuition, and clean code in every language — free, no credit card.

Create a free account Already have an account? Sign in