AISD: pracownia A

Pracownia A.

Testy alistry

Testy alistry (max.in, bin.in, np.in, prime.in) (spełniają specyfikację)

Odpowiedzi:

drx$ ./a.out <max.in
4422180
drx$ ./a.out <np.in
6438856
drx$ ./a.out <prime.in
5768009
drx$ ./a.out <bin.in
9500001

Inne testy

meh, dane nie spelniaja warunku: Dowolne dwie pary w danych wejsciowych maja rózne wartosci d.

http://www.student.ii.uni.wroc.pl/~i221072/testy/ - 15 duzych testow
http://www.student.ii.uni.wroc.pl/~i221072/testy.tar.bz2 - archiwum
http://dude.bshellz.net/test/odp-dude.tar.bz2 - odpowiedzi dude, kontakt przez IRC. Wygenerowane przez program zaakceptowany przez sprawdzarke.

Niech sobie nie spełniają, po co? Dobrze napisany program sobie poradzi
Jak ma sobie poradzić, ma wziąć pierwszy wynik, ostatni czy sumę? nie jest sprecyzowane, wiec wsadź sobie te testy

Wyniki

http://www.ii.uni.wroc.pl/~mbi/dyd/aisd_10s/wyniki_A.html - wyniki
0 oznacza wystapenie jakiegos bledu.

Wygenerowane programem w perlu (po obcieciu gory i dolu strony)

#!/usr/bin/perl -w
 
undef $/;
$_ = nopl(<>);
while (/\G.*?<tr>(.*?)<\/tr>/gs) {
        $one = $1;
        $one =~ /.*?<td class="left">(.*?)<\/td>/;
        $who = $1;
        $one = $';
        $one =~ /.*?<td>.*?<\/td>.*?<td>\d*?<\/td>/;
        $one = $';
        $sum = 0;
        while ($one =~ /\G.*?<td class=".*?">(.*?)<br><span class="small">(\d*?)\/(\d*)?<\/span><\/td>/gs) {
                $1 ne "OK" && do { $sum = 0; last } || ($sum += $2);
        }
        print "$sum:\t$who\n";
}
 
sub nopl {
        $_ = shift;
        s/\xC4\x84/A/g; s/\xC4\x86/C/g; s/\xC4\x98/E/g; s/\xC5\x81/L/g; s/\xC5\x83/N/g; s/\xC3\x93/O/g;
        s/\xC5\x9A/S/g; s/\xC5\xB9/Z/g; s/\xC5\xBB/Z/g; s/\xC4\x85/a/g; s/\xC4\x87/c/g; s/\xC4\x99/e/g;
        s/\xC5\x82/l/g; s/\xC5\x84/n/g; s/\xC3\xB3/o/g; s/\xC5\x9B/s/g; s/\xC5\xBA/z/g; s/\xC5\xBC/z/g;
        tr/\xF3\xEA\xB6\xB1\xBF\xB3\xE6\xBC\xCA\xF1\xA1\xD3\xA3\xA6\xAC\xAF\xD1\xC6\x9C\xB9\x9F\xA5\x8C\x8F/oesazlczEnAOLSZZNCsazASZ/;
        s/[\x80-\xFF]/?/g;
        return $_;
}

0:      Ale Wozn
0:      And Kaje
0:      Bar Krok
0:      Dam Piat
0:      Dam Wiec
0:      Fil Slom
0:      Grz Chud
0:      Jad Gruc
0:      Jan Nowa (test)
0:      Jar Jawo
0:      Kon Wypy
0:      Kor Wegr
0:      Krz Pnia (test)
0:      Luk Jazw
0:      Luk Syno
0:      Luk Wrza
0:      Mac Pawl
0:      Mar Alek
0:      Mic Jedr
0:      Mic Marc (test)
0:      Paw Mete
0:      Pio Bzow
0:      Pio Walk
0:      Raf Kowa
0:      Seb Majk
1020:   Mic Mazu
1096:   Bar Cwik
1264:   Mik Kali
1696:   EK G (test)
2360:   Paw Chwa (test)
2448:   Paw Chwa
4356:   Dom Rusa
4472:   Ale Bali
4512:   Luk Zapa
4528:   Mar Janu
4532:   Ada Kacz
4532:   Grz Kasz
4532:   Wal Augu (test)
4532:   Wil Wonk (test)
4552:   Raf Luka
4564:   Pio Pole
4608:   Krz Kusi
4616:   Mar Ryba
4644:   Wik Jana
4656:   Paw Kici
4672:   Pio Ryba
4680:   Pio Ryba (test)
4696:   Jak Tarn
4716:   Krz Piec (test)
4732:   Mar Ocze
4740:   Krz Nowi
4768:   Daw Jurc
4768:   Mic Roza
4800:   Kam Miel
4804:   Mic Kras
4812:   Sla Step
4832:   Mar Kola
4872:   Kac Krol
4880:   Mar Janc
4904:   Dom Rogo
4924:   Rad Kotk
4956:   Krz Dabr
5032:   Grz Kurd
5136:   Pat Obar
5140:   Paw Muri
5172:   Kam Shai
5172:   Kar Kona
5184:   Dam Stra
5228:   Mar Kowa
5236:   Krz Parj
5240:   Mag Sara
5268:   Dom Brul
5268:   Krz Ziel (test)
5316:   Joa Bieg
5348:   Paw Kime
5376:   Daw Ryzn
5404:   Krz Kraw
5412:   Luc Fran
5480:   Luk Toma
5492:   Fab Krol
5528:   Krz Ziel
5688:   Iza Bicz
5732:   Tom Losz
5776:   Dam Rusa
5836:   Pio Rzep
5840:   Pio Gajo
6048:   Mar Kacz
6060:   Are Flin
6156:   Ale Gali
6172:   Adr Dyli
6596:   Ada Wyzg
7028:   Pat Urba
7080:   Mac Maty
7160:   Paw Kali
7648:   Ark Goch
7848:   Bla Sala
8104:   Dan Blas
8376:   Tom Luch
8484:   Szy Lasz
8648:   Mic Karp
8696:   Mic Glen
8840:   Pio Krze
8964:   Mac Pacu
9440:   Daw Cies
9984:   Ada Kija
10196:  Jak Sliw
10288:  Paw Kacp
13752:  Mic Soko
13904:  Mat Naha
14512:  Mat Naha (test)
15232:  Mal Jurk
15416:  Mac Wiec
15476:  Mik Ziem

Rozwiązanie (dude)

#include <stdio.h>
 
#define MAX     (1000000 >> 1)
 
union {
        unsigned long long int  i;
        unsigned char           c[8];
} tab[MAX];
 
char ones[256] = {
        0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
        1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
        1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
        2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
        1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
        2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
        2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
        3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8,
};
 
#define READ_INT(n)     n = 0; while((ch = getchar_unlocked()) >= '0') n = n * 10 + ch - '0';
int main()
{
        int     n, i, j, num, len, l2, max = 0, min = MAX;
        char    ch;
 
        READ_INT(n);
        while (n--) {
                READ_INT(num);
                READ_INT(len);
                for (l2 = 0; !(num&1); num >>= 1, l2++);
                tab[num >>= 1].i += (unsigned long long int) len << l2;
                if (max < num) max = num;
                if (min > num) min = num;
        }
 
        for (n = 0, i = min; i <= max; i++)
                if (tab[i].i) for (j = 0; j < 8; n += ones[tab[i].c[j++]]);
 
        printf("%d\n", n);
        return 0;
}

Rozwiązanie (biff)

 #include <stdio.h>
 #define READ_INT(a) a = 0; \
                     while ((ch = getchar_unlocked()) >= '0') \
                        a = a * 10 + (ch - '0');
 
 static const unsigned char popcount[256], powers[32];
 unsigned long long strings[5000001], count;
 unsigned int hash [1000000] = {0,1,2};
 
 int main (void) {
 
    unsigned int residue, i, number_of_strings, p=3;
    unsigned char power = 0, ch, *r;
 
    READ_INT(i)
 
    while (i --> 0) {
       READ_INT(residue)
       READ_INT(number_of_strings)
 
       if (residue != 1) {
          power = powers[((residue& -residue) * 0x46569F7UL) >> 27];
          residue >>= power;
 
          if (residue == 1) {
             residue <<= 1;
             power --;
          }
       }
 
       if (hash[residue] == 0) hash[residue] = p++;
 
       strings[hash[residue]] += ((unsigned long long)number_of_strings << power);
    }
 
    count = strings[1] % 2;
    strings[2] += (strings[1] >> 1);
 
    r = (unsigned char *) (strings+2);
    for (unsigned long long i = 2; i < p; i++) {
       count += popcount[r[0]] + popcount[r[1]] +  popcount[r[2]] + popcount[r[3]]
             +  popcount[r[4]] + popcount[r[5]] +  popcount[r[6]] + popcount[r[7]];
       r+=8;
    }
 
    printf ("%llu\n", count);
    return 0;
 }
 
 static const unsigned char popcount[256] =
   { 0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,1,2,2,3,
     2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,1,2,2,3,2,3,3,4,
     2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,2,3,3,4,3,4,4,5,3,4,4,5,
     4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
     2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,
     4,5,5,6,4,5,5,6,5,6,6,7,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,
     4,5,5,6,5,6,6,7,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,4,5,5,6,5,6,6,7,5,6,6,7,
     6,7,7,8};
 
 static const unsigned char powers[32] =
   { 0,1,2,6,3,11,7,21,4,19,12,14,8,16,28,22,31,
     5,10,20,18,13,15,27,30,9,17,26,29,25,24,23 };