Zagadka logiczna

0

Cześć, mam problem logiczny i w żaden sposób nie mogę znaleźć wyniku.
O co chodzi: jest liczba w postaci binarnej i na jej podstawie jest tworzony bajt. Pytanie w jaki sposób, oto zestaw danych przykładowych:

Liczba: 00001000 01011100 01110010 00100000
bajt: 11001000

liczba: 00001000 00100101 01000110 01101000
bajt: 01001000

liczba: 00001000 10100000 11111101 11101010
bajt: 01011000

liczba: 00001000 01110111 11111100 11101010
bajt: 01011000

liczba: 00001000 00000100 00000011 11101011
bajt: 01011000

liczba: 00001000 00001000 10011001 11101010
bajt: 01011000

liczba: 00001000 11100101 11001111 11101010
bajt: 01011000

liczba: 00001000 10010001 00110010 00111101
bajt: 10111000

Wg mnie najbardziej liczą się 2 skrajne bajty, ale w jaki sposób to nie mam pojęcia.

0

Masz może trochę więcej danych przykładowych?

Na początku myślałem że ostateczny bajt to suma 4 składowych (mod 256). Niestety nie... Sprawdziłem dodatkowo, żadna kombinacja operacji dodawania, odejmowania, mnożenia, dzielenia, and, or, xor i mod nie prowadzi do wyniku.

Zająłem się za to poszczególnymi bitami, i wygląda to tak:

                   A B CD
 01011100 01110010 00100000
 00100101 01000110 01101000
 10100000 11111101 11101010
 01110111 11111100 11101010
 00000100 00000011 11101011
 00001000 10011001 11101010
 11100101 11001111 11101010
;10010001 00110010 00111101

~C  B  D  A
 1  1  0  0
 0  1  0  0
 0  1  0  1
 0  1  0  1
 0  1  0  1
 0  1  0  1
 0  1  0  1
;1  0  1  1

Za wyjątkiem ostatniego bajta który do niczego nie pasuje (dosłownie, to praktycznie negatyw poprawnego rozwiązania) wszystko się podejrzanie zgadza. Dość dużo jak na zbieg okoliczności, ale kto wie...

0

może jakaś podpowiedź skąd to masz?
i czy możesz sam wprowadzać dane na wejście? jak tak to zapodałbyś kilka przykładowych danych koło siebie

0

Idąc tropem MSMa wykombinowałem coś takiego:

                   AC B D
 01011100 01110010 00100000
 00100101 01000110 01101000
 10100000 11111101 11101010
 01110111 11111100 11101010
 00000100 00000011 11101011
 00001000 10011001 11101010
 11100101 11001111 11101010
 10010001 00110010 00111101

~C ~B  D  A
 1  1  0  0
 0  1  0  0
 0  1  0  1
 0  1  0  1
 0  1  0  1
 0  1  0  1
 0  1  0  1
 1  0  1  1

Tylko mi się A w ostatnim nie zgadza

0
  1. wymagany GCC, albo przerobić liczby binarne na hex albo dec
  2. może być potrzebna zamiana kolejności bajtów (endianess)
  if (liczba = 0b00001000010111000111001000100000)
    bajt = 0b11001000;
  else if (liczba = 0b00001000001001010100011001101000)
    bajt = 0b01001000;
  else if (liczba = 0b00001000101000001111110111101010)
    bajt = 0b01011000;
  else if (liczba = 0b00001000011101111111110011101010)
    bajt = 0b01011000;
  else if (liczba = 0b00001000000001000000001111101011)
    bajt = 0b01011000;
  else if (liczba = 0b00001000000010001001100111101010)
    bajt = 0b01011000;
  else if (liczba = 0b00001000111001011100111111101010)
    bajt = 0b01011000;
  else if (liczba = 0b00001000100100010011001000111101)
    bajt = 0b10111000;
  else throw "dupa";

tyle można powiedzieć z pewnością na podstawie danych.

0
unikalna_nazwa napisał(a)

może jakaś podpowiedź skąd to masz?
i czy możesz sam wprowadzać dane na wejście? jak tak to zapodałbyś kilka przykładowych danych koło siebie

Dane mogę sam wprowadzać. Chodzi o numery kart sczytywanych przez dwa urządzenia różnych firm. Niestety ze względu na ograniczoną ilość zbliżeniówek nie mam więcej danych.

Też wymyśliłem kilka teorii i zawsze jeden albo dwa się nie zgadzały ;>

0

Jakich urządzeń? Może po prostu poszukaj jakiejś specyfikacji zamiast się z bitami bawić?
Tak czy inaczej na chwilę obecną Azarien ma rację...

0

możesz też zwracać zawsze 01011000 z 62,5% szansą trafienia ;)
a to nie są po prostu jakieś identyfikatory kart, a ten bajt na wyjściu to po prostu uprawnienia przypisane danej karcie w bazie danych?

nie za bardzo widzę inny sens produkowania jednego bajta z czterech poza czymś takim i jakąś funkcją hashującą ale to odpada bo coś ten zwracany "hash" jest za bardzo kolizyjny

0

zbuduj sieć neuronową, naucz znanymi danymi i zobacz może na coś wpadnie :-)

0

Mam nadzieje, ze jeszcze sie przyda autorowi :) Szkoda, ze wczesniej przeoczylem ten watek(lubie zagadki:)) :/
Moja 'wizja'(kolejnosc troche zmieniona):

                  xGxHxIJK
10100000 11111101 11101010
 bajt: 0101
01110111 11111100 11101010
 bajt: 0101
00000100 00000011 11101011
 bajt: 0101
00001000 10011001 11101010
 bajt: 0101
11100101 11001111 11101010
 bajt: 0101 
01011100 01110010 00100000
 bajt: 1100
00100101 01000110 01101000
 bajt: 0100 
10010001 00110010 00111101
 bajt: 1011

A = ~G, B = ~H, C = I, D = J or K. Bajt to ABCD. Przykladowo pierwszy(z listy autora tematu) przypadek:
00001000 01011100 01110010 00100000 -> 00100000 czyli G, H, I, J, K = 0. Z tego wynika, że A = 1, B=1, C=0, D=0 -> 1100
Ostatni z listy przypadek:
00001000 10010001 00110010 00111101 -> 00111101 -> G=0, H=1, I=1, J=0, K=1 -> A=1, B=0, C=1, D=1 ->1011
Wydaje mi się, że jest ok w każdym przypadku.... chociaż i tak uwazam, ze ten algorytm wyglada 'jakos inaczej' i gdybysmy mieli wiecej przykladowych danych to dla ktorego zestawu moj sposob by nie zadzialal ;)

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0