How can I generate this pattern of numbers?

Question

Given inputs 1-32 how can I generate the below output?

in. out

1. 1
2. 1
3. 1
4. 1
5. 2
6. 2
7. 2
8. 2
9. 1
10. 1
11. 1
12. 1
13. 2
14. 2
15. 2
16. 2 ...

Edit Not Homework.. just lack of sleep.

I am working in C#, but I was looking for a language agnostic algorithm.

Edit 2 To provide a bit more background... I have an array of 32 items that represents a two dimensional checkerboard. I needed the last part of this algorithm to convert between the vector and the graph, where the index aligns on the black squares on the checkerboard.

Final Code:

 --Index;
 int row = Index >> 2;
 int col = 2 * Index - (((Index & 0x04) >> 2 == 1) ? 2 : 1);

Answer 1

In Perl:

#!/usr/bin/perl

use strict; use warnings;

sub it {
    return sub {
        my ($n) = @_;
        return 1 if 4 > ($n - 1) % 8;
        return 2;
    }
}

my $it = it();

for my $x (1 .. 32) {
    printf "%2d:%d\n", $x, $it->($x);
}

Or:

sub it {
    return sub {
        my ($n) = @_;
        use integer;
        return 1 + ( (($n - 1) / 4) % 2 );
    }
}

Answer 2

You could use a combination of integer division and modulo 2 (even-odd): There are blocks of four, and the 1st, 3rd, 5th block and so on should result in 1, the 2nd, 4th, 6th and so on in 2.

s := ((n-1) div 4) mod 2;
return s + 1;

div is supposed to be integer division.

EDIT: Turned first mod into a div, of course

Answer 3

in C:

char output = "11112222"[input-1 & 7];

or

char output = (input-1 >> 2 & 1) + '1';

or after an idea of FogleBird:

char output = input - 1 & 4 ? '2' : '1';

or after an idea of Steve Jessop:

char output = '2' - (0x1e1e1e1e >> input & 1);

or

char output = "12"[input-1>>2&1];

C operator precedence is evil. Do use my code as bad examples :-)

Answer 4

Python

def f(x):
    return int((x - 1) % 8 > 3) + 1

Or:

def f(x):
    return 2 if (x - 1) & 4 else 1

Or:

def f(x):
    return (((x - 1) & 4) >> 2) + 1

Answer 5

Assuming that you can use bitwise operators you can check what the numbers with same output have in common, in this case I preferred using input 0-31 because it's simpler (you can just subtract 1 to actual values)

What you have?

0x0000 -> 1
0x0001 -> 1
0x0010 -> 1
0x0011 -> 1
0x0100 -> 2
0x0101 -> 2
0x0110 -> 2
0x0111 -> 2
0x1000 -> 1
0x1001 -> 1
0x1010 -> 1
0x1011 -> 1
0x1100 -> 2
...

It's quite easy if you notice that third bit is always 0 when output should be 1 and viceversa it's always 1 when output should be 2

so:

char codify(char input)
{
     return ((((input-1)&0x04)>>2 == 1)?(2):(1));
}

EDIT

As suggested by comment it should work also with

char codify(char input)
{
     return ((input-1 & 0x04)?(2):(1));
}

because in some languages (like C) 0 will evaluate to false and any other value to true. I'm not sure if it works in C# too because I've never programmed in that language. Of course this is not a language-agnostic answer but it's more C-elegant!

Answer 6

It depends of the language you are using.

In VB.NET, you could do something like this :

for i as integer = 1 to 32
   dim intAnswer as integer = 1 + (Math.Floor((i-1) / 4) mod 2)
   ' Do whatever you need to do with it
next

It might sound complicated, but it's only because I put it into a sigle line.

Answer 7

Thats pretty straightforward:

if (input == "1") {Console.WriteLine(1)};
if (input == "2") {Console.WriteLine(1)};
if (input == "3") {Console.WriteLine(1)};
if (input == "4") {Console.WriteLine(1)};
if (input == "5") {Console.WriteLine(2)};
if (input == "6") {Console.WriteLine(2)};
if (input == "7") {Console.WriteLine(2)};
if (input == "8") {Console.WriteLine(2)};

etc...

HTH

Answer 8

Just for laughs, here's a technique that maps inputs 1..32 to two possible outputs, in any arbitrary way known at compile time:

// binary 1111 0000 1111 0000 1111 0000 1111 0000
const uint32_t lu_table = 0xF0F0F0F0;

// select 1 bit out of the table
if (((1 << (input-1)) & lu_table) == 0) {
    return 1;
} else {
    return 2;
}

By changing the constant, you can handle whatever pattern of outputs you want. Obviously in your case there's a pattern which means it can probably be done faster (since no shift is needed), but everyone else already did that. Also, it's more common for a lookup table to be an array, but that's not necessary here.

Answer 9

In Groovy:

def codify = { i  ->
    return  (((((i-1)/4).intValue()) %2 ) + 1)
}

Then:

def list = 1..16
list.each {
    println "${it}: ${codify(it)}"
}

Answer 10

In Haskell:

vec2graph :: Int -> Char
vec2graph n = (cycle "11112222") !! (n-1)

Answer 11

The accepted answer return ((((input-1)&0x04)>>2 == 1)?(2):(1)); uses a branch while I would have just written:

return 1 + ((input-1) & 0x04 ) >> 2;

Answer 12

char codify(char input)
{
     return  (((input-1) & 0x04)>>2) + 1;
}

Answer 13

Using Python:

output = 1
for i in range(1, 32+1):
  print "%d. %d" % (i, output)
  if i % 4 == 0:
    output = output == 1 and 2 or 1

Answer 14

JavaScript

My first thought was

output = ((input - 1 & 4) >> 2) + 1;

but drhirsch's code works fine in JavaScript:

output = input - 1 & 4 ? 2 : 1;

and the ridiculous (related to FogleBird's answer):

output = -~((input - 1) % 8 > 3);

Answer 15

Java, using modulo operation ('%') to give the cyclic behaviour (0,1,2...7) and then a ternary if to 'round' to 1(?) or 2(:) depending on returned value. ...

 public static void main(String[] args) {
        for (int i=1;i<=32;i++) {
             System.out.println(i+"="+ (i%8<4?1:2) );
    }

Produces:

1=1 2=1 3=1 4=2 5=2 6=2 7=2 8=1 9=1 10=1 11=1 12=2 13=2 14=2 15=2 16=1 17=1 18=1 19=1 20=2 21=2 22=2 23=2 24=1 25=1 26=1 27=1 28=2 29=2 30=2 31=2 32=1