codeforces-scrape

Codeforces scraped problems and editorials
git clone git://git.laack.co/codeforces-scrape.git
Log | Files | Refs | README

1152B.md (2742B)


      1 Source: https://codeforces.com/problemset/problem/1152/B
      2 
      3 B. Neko Performs Cat Furrier Transform
      4 
      5 time limit per test
      6 
      7 1 second
      8 
      9 memory limit per test
     10 
     11 256 megabytes
     12 
     13 input
     14 
     15 standard input
     16 
     17 output
     18 
     19 standard output
     20 
     21 Cat Furrier Transform is a popular algorithm among cat programmers to create longcats. As one of the greatest cat programmers ever exist, Neko wants to utilize this algorithm to create the perfect longcat.
     22 
     23 Assume that we have a cat with a number $x$. A perfect longcat is a cat with a number equal $2^m - 1$ for some non-negative integer $m$. For example, the numbers $0$, $1$, $3$, $7$, $15$ and so on are suitable for the perfect longcats.
     24 
     25 In the Cat Furrier Transform, the following operations can be performed on $x$:
     26 
     27 * (Operation A): you select any non-negative integer $n$ and replace $x$ with $x \oplus (2^n - 1)$, with $\oplus$ being a [bitwise XOR operator](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
     28 * (Operation B): replace $x$ with $x + 1$.
     29 
     30 The first applied operation must be of type A, the second of type B, the third of type A again, and so on. Formally, if we number operations from one in the order they are executed, then odd-numbered operations must be of type A and the even-numbered operations must be of type B.
     31 
     32 Neko wants to produce perfect longcats at industrial scale, thus for each cat Neko only wants to perform at most $40$ operations. Can you help Neko writing a transformation plan?
     33 
     34 Note that it is not required to minimize the number of operations. You just need to use no more than $40$ operations.
     35 
     36 Input
     37 
     38 The only line contains a single integer $x$ ($1 \le x \le 10^6$).
     39 
     40 Output
     41 
     42 The first line should contain a single integer $t$ ($0 \le t \le 40$) — the number of operations to apply.
     43 
     44 Then for each odd-numbered operation print the corresponding number $n_i$ in it. That is, print $\lceil \frac{t}{2} \rceil$ integers $n_i$ ($0 \le n_i \le 30$), denoting the replacement $x$ with $x \oplus (2^{n_i} - 1)$ in the corresponding step.
     45 
     46 If there are multiple possible answers, you can print any of them. It is possible to show, that there is at least one answer in the constraints of this problem.
     47 
     48 Examples
     49 
     50 Input
     51 
     52 ```
     53 39
     54 ```
     55 
     56 Output
     57 
     58 ```
     59 4
     60 5 3
     61 ```
     62 
     63 Input
     64 
     65 ```
     66 1
     67 ```
     68 
     69 Output
     70 
     71 ```
     72 0
     73 ```
     74 
     75 Input
     76 
     77 ```
     78 7
     79 ```
     80 
     81 Output
     82 
     83 ```
     84 0
     85 ```
     86 
     87 Note
     88 
     89 In the first test, one of the transforms might be as follows: $39 \to 56 \to 57 \to 62 \to 63$. Or more precisely:
     90 
     91 1. Pick $n = 5$. $x$ is transformed into $39 \oplus 31$, or $56$.
     92 2. Increase $x$ by $1$, changing its value to $57$.
     93 3. Pick $n = 3$. $x$ is transformed into $57 \oplus 7$, or $62$.
     94 4. Increase $x$ by $1$, changing its value to $63 = 2^6 - 1$.
     95 
     96 In the second and third test, the number already satisfies the goal requirement.