Pattern decoding - linux

Question

I need a little help in the following. I have this kind of datafile:
0 0 # <--- Group 1 -- 1 house (0) and 1 room (0)
0 0 # <--- Group 2 -- 2 houses (0;1) and 3,2 rooms (0,1,2;0,1)
0 1
0 2
1 0 # <--- house 2 in Group 2, with the first room (0)
1 1 # <--- house 2 in Group 2, with the second room (1)
0 0 # <--- Group 3
0 1 # <--- house 1 in Group 3, with the second room (1)
0 2
0 0 # <--- Group 4
1 0 # <--- house 2 in Group 4, with one room only (0)
2 0
3 0 # <--- house 4 in Group 4, with one room only (0)
0 0 # <--- Group 5
0 0 # <--- Group 6
There are some cases, which have to be answered:
There are groups in the example; there exists a group, if it is separated by new lines from the other, so in this case we have 6 groups. We have to determine the followings
Get the actual number (ordinal number) of the group (the counter starts for example from 1)
if the 1st column = 0 and the 2nd column = 0 and the next line is empty
So the desired output according to the above example would be
1
5
6
if the first column = 0 and the 2nd column can vary and the next line is empty
So the desired output according to the above example would be
3
... etc. How can this be generalized in a way that we can set at the beginning which case would we like to get ?
There might be many cases according to the values of the columns in a group.
We can imagine this if we think about something like this: the first column means the number of houses in a street, and the second column means the number of rooms in a house. Now I would like to find all possible kind of streets in a city, which means for example
let us pick up those streets, in which there are two houses with different number of rooms, in the first house there are 3 rooms, and in the second house there are 2 rooms. So we have the get output 2, becasue this requirement fulfills this group in the file
0 0
0 1
0 2
1 0
1 1
Important: 0 0 means there is one house with one room
Correction: if there is one house only, then it has just one room all the time! Like in the cases Group 1, Group 5, and Group 6. Remember, that the second column is the number of room, and 0 mean "1 room", 1 means "2 rooms", ...etc. This is just a counter which starts from 0, instead of 1, sorry if it is confusing a little bit...

Answer 1

I don't know what would be your expected output, however I have converted/decoded your number pattern to a meaningful group/house/rooms format. any further "query" could be done on this content.
see below:
kent$ cat file
0 0
0 0
0 1
0 2
1 0
1 1
0 0
0 1
0 2
0 0
1 0
2 0
3 0
0 0
0 0
awk:
kent$ awk 'BEGIN{RS=""}
{ print "\ngroup "++g;
delete a;
for(i=1;i<=NF;i++) if(i%2) a[$i]++;
for(x in a) printf "House#: %s , Room(s): %s \n", x, a[x]; }' file
we get output:
group 1
House#: 0 , Room(s): 1
group 2
House#: 0 , Room(s): 3
House#: 1 , Room(s): 2
group 3
House#: 0 , Room(s): 3
group 4
House#: 0 , Room(s): 1
House#: 1 , Room(s): 1
House#: 2 , Room(s): 1
House#: 3 , Room(s): 1
group 5
House#: 0 , Room(s): 1
group 6
House#: 0 , Room(s): 1
note that the generated format could be changed to fit your "filter" or "query"
UPDATE
OP's comment:
I need to know, the number of the group(s) which have/has for example
1 house with one room. The output would be in the above case: 1, 5 ,6
as I said, based on your query criteria, we could adjust the awk output for next step. now I change the awk abovet to:
awk 'BEGIN{RS=""}
{print ""; gid=++g;
delete a;
for(i=1;i<=NF;i++) if(i%2) a[$i]++;
for(x in a) printf "%s %s %s\n", gid,x, a[x]; }' file
this will output:
1 0 1
2 0 3
2 1 2
3 0 3
4 0 1
4 1 1
4 2 1
4 3 1
5 0 1
6 0 1
the format is groupIdx houseIdx numberOfRooms and there is a blank line between groups. we save the text above to a file named decoded.txt
so your query could be done on this text:
kent$ awk 'BEGIN{RS="\n\n"}{if (NF==3 && $3==1)print $1}' decoded.txt
1
5
6
the last awk line above means, print the group number, if room number ($3) = 1 and there is only one line in the group block.

Answer 2

I would first define a House class and a Group class:
class House:
def __init__(self, rooms):
self.rooms = rooms
class Group:
def __init__(self, index, houses):
self.index = index
# houses.values() is a list with number of rooms for each house.
self.houses = [House(houses[house_nr]) for house_nr in sorted(houses)]
def __str__(self):
return 'Group {}'.format(self.index)
def __repr__(self):
return 'Group {}'.format(self.index)
Then parse the data into this hierarchical structure:
with open('in.txt') as f:
groups = []
# Variable to accumulate current group.
group = collections.defaultdict(int)
i = 1
for line in f:
if not line.strip():
# Empty line found, create a new group.
groups.append(Group(i, group))
# Reset accumulator.
group = collections.defaultdict(int)
i += 1
continue
house_nr, room_nr = line.split()
group[house_nr] += 1
# Create the last group at EOF
groups.append(Group(i, group))
Then you can do stuff like this:
found = filter(
lambda g:
len(g.houses) == 1 and # Group contains one house
g.houses[0].rooms == 1, # First house contains one room
groups)
print(list(found)) # Prints [Group 1, Group 5, Group 6]
found = filter(
lambda g:
len(g.houses) == 2 and # Group contains two houses
g.houses[0].rooms == 3 and # First house contains three rooms
g.houses[1].rooms == 2, # Second house contains two rooms
groups)
print(list(found)) # Prints [Group 2]

Answer 3

Perl solution. It converts the input into this format:
1|0
2|1 2
3|2
4|0 0 0 0
5|0
6|0
The first column is group number, in second column there are number of rooms (minus one) of all its houses, sorted. To search for group with two different houses with 2 and 3 rooms, you can just grep '|1 2$', to search for groups with just one house with one room, grep '|0$'
#!/usr/bin/perl
#-*- cperl -*-
#use Data::Dumper;
use warnings;
use strict;
sub report {
print join ' ', sort {$a <=> $b} #_;
print "\n";
}
my $group = 1;
my #last = (0);
print '1|';
my #houses = ();
while (<>) {
if (/^$/) { # group end
report(#houses, $last[1]);
undef #houses;
print ++$group, '|';
#last = (0);
} else {
my #tuple = split;
if ($tuple[0] != $last[0]) { # new house
push #houses, $last[1];
}
#last = #tuple;
}
}
report(#houses, $last[1]);
It is based on the fact that for each house, only the last line is important.