Forum strony www.multipasko.pl [Regulamin]


Dodaj wpis w tym temacie
Spis tematów
Login:

Hasło:
Strona: 1 2 ... 324 325 326 ... 561 562

Wyślij wiadomość do admina
🎱 MultiPairs 2027 – nowa wersja w przeglądarce, otwórz BETA

Przewiń wpisy ↓

moje ... oprogramowanie

2020-04-28 (21:50)

status 777ch
Data rejestracji: 2005-11-07
Ilość postów: 23259

1386
wpis nr 1 288 968
[ CZCIONKA MONOSPACE ]

widzę potencjał
ale po 3 drinkach zawsze ......coś widzę


dzięki za wstawki ,jutro odpowiem jak się
--> temu .....dokładniej przyjrzę
pozdrawiam
2020-04-28 (22:28)

status fair_play
Data rejestracji: 2016-05-12
Ilość postów: 9076

14865
wpis nr 1 288 983
[ CZCIONKA MONOSPACE ]

Opiszę krótko ideę.

1. Tworzę matrycę zakładów - mat()

2. Obliczam ilość kombinacji (v po 6) i deklaruję tablicę adresów maska() as BYTE o takim rozmiarze. (i tutaj powstaje problem pamięci)

3. Dla każdej linii rozpisu dla każdej kolejnej "szóstki" obliczam jej adres i pod tym adresem inkrementuję komórkę tablicy adresów.

4. Skanuję tablicę adresów i sumuję ilość poszczególnych wartości w kolejnych jej komórkach.
wartość 0 - brak szóskti
wartość > 1 oznacza że występuje przypisana temu adresowi szóstka o odczytanej krotności wystąpień w rozpisie.

I to wszystko

Mając konkretny adres brakującej szóstki w razie potrzeby łatwo odtworzyć tworzące ją liczby, ale to już inna procedura

Zapomniałem dodać, że ustawiam Option Base 1

--- wpis edytowano 2020-04-28 22:35 ---

2020-04-28 (22:47)

status 777ch
Data rejestracji: 2005-11-07
Ilość postów: 23259

1386
wpis nr 1 288 985
[ CZCIONKA MONOSPACE ]

To mniej więcej tak
jak działam na danych
jakie mogę ująć w tablicach wielowymiarowych

i tak do punktu 2

punkt 3 przemyślę jutro
bo to....coś nowego

pozdrawiam

2020-04-29 (01:44)

status 777ch
Data rejestracji: 2005-11-07
Ilość postów: 23259

1386
wpis nr 1 289 003
[ CZCIONKA MONOSPACE ]

fair_play

W programie mam zadeklarowaną ogromną pamięć
dla 6 tablic:

tr6: array [1 .. 21, 2 .. 22, 3 .. 23, 4 .. 24, 5 .. 25, 6 .. 26]of integer;
tr5: array [1 .. 45, 2 .. 46, 3 .. 47, 4 .. 48, 5 .. 49] of integer;
tr4: array [1 .. 96, 2 .. 97, 3 .. 98, 4 .. 99] of integer;
tr3: array [1 .. 97, 2 .. 98, 3 .. 99] of integer;
tr2: array [1 .. 98, 2 .. 99] of integer;


Twoja procedura również opiera się na odwołaniu do
maska(adr0) .......czyli kolejnej tablicy
której rozmiar będzie mniejszy ,ale musi zawierać co najmniej
--> =Combine(liczb, traf)..aby odnotować index kolejnej szóstki
-->czyli paskalowskie Combination(v,6);

aby na końcu sprawdzić czy index[csn]
danej 6-ki został odczytany

For y = 1 To adr0
If maska(y) = 0 Then brak = brak + 1
Next


To jest na ten moment problem
i dlatego wcześniej ,obliczenia gwarancji w tablicach
oparłem o ich możliwy rozmiar sumaryczny

a ponieważ nic więcej się....."nie zmieści"
dla V którego tablice nie pomieszczą
zrobiłem tylko sprawdzenie......wolne strasznie
bo bez odwołania do indeksów

gdybym chciał teraz to pozmieniać
to albo kompletne przerobienie
z specjalizacją dla k

albo zrobienie osobnych programików
dla gwar 6,gwar 7 itd.

Zawsze chodzi o braki sprzętowe,
albo o pamięć,
i również jej umiejętną alokację


Chyba sobie na razie odpuszczę przeróbki,
bo musiałbym sporo pozmieniać ,
aby zrobić --> przestrzeń pamięciową,
bo pamięć zasadnicza nie jest zwalniana
jedynie ta lokalna.....

nie mniej zainteresowałeś mnie trochę
choć podobne rozwiązania mam już w excelu
tam dla każdej 6-ki jest obliczany csn
co nieco spowalnia ,
ale głównym problemem dla dużych liczb
była i jest jest własnie --> tablica csn-ów czyli indeksów

dobrej nocki


2020-04-29 (09:48)

status fair_play
Data rejestracji: 2016-05-12
Ilość postów: 9076

14865
wpis nr 1 289 028
[ CZCIONKA MONOSPACE ]

777ch>

Mój dziadek mawiał również "kto rano wstaje...ten się nie wyśpi", ale zaryzykowałem.

Pisałem, że przy tej metodzie krytyczną sprawą jest dostępna pamięć, ale...

Swego czasu, jeszcze w czasach "ATARI" pisałem programy bezpośrednio w kodzie maszynowym bez assemblera (Motorola 6502), Do dziś pamiętam kody tego procesora. Np skok bezwzględny oznaczała instrukcja 4C xx xx, wywołanie procedury 20 xx xx, gdzie xx xx to adresy.

I tam przy użyciu operatorów AND i OR można było sprawdzić czy jest ustawiony, lub ustawić odpowiedni bit w komórce pamięci Np AND 30 sprawdza czy jest ustawiony 6-ty bit, a OR 30 ustawia ten bit (nawet jeśli jest już ustawiony.

Nie wiem czy w Pascalu można operować na bitach, ale mając do dyspozycji 8 lub 16 bitów można podzielić tablicę adresów na 8 lub 16 części, za pomocą MOD i DIV zapalać odpowiedni jej bit i w ten sposób zmniejszyć zapotrzebowanie na pamięć 8-mio lub 16-to krotnie.

A pomijając kwestię pamięci to jak wygląda mój pomysł pod względem czasu obliczeń ?

Pozdrawiam

--- wpis edytowano 2020-04-29 10:03 ---

2020-04-29 (10:34)

status fair_play
Data rejestracji: 2016-05-12
Ilość postów: 9076

14865
wpis nr 1 289 034
[ CZCIONKA MONOSPACE ]

777ch>

Przysłowie dziadka się sprawdziło bo oczywista pomyłka

AND 30 sprawdza czy są ustawione jednocześnie 5-ty i 6-ty bit, a OR 30 ustawia te bity nawet jeśli są już ustawione. Do sprawdzania i ustawiania pojedyńczych bitów powinno być AND 01, 02, 04,08,10,20,40, 80 (kod szestnastkowy).
2020-04-29 (12:04)

status 777ch
Data rejestracji: 2005-11-07
Ilość postów: 23259

1386
wpis nr 1 289 050
[ CZCIONKA MONOSPACE ]

HEJ

Manipulacje bitami,działania na ciągach bitów to ..... obawiam się biała kartka
w moim kajecie .

Dziadek ma zawsze rację.


------------
A pomijając kwestię pamięci to jak wygląda mój pomysł pod względem czasu obliczeń ?
------------

pomysł jest dobry......
tylko komu i na co to potrzebne .........
żartuję sobie ,i ..... jeszcze śpię

--- wpis edytowano 2020-04-29 12:10 ---

2020-04-29 (12:06)

status 777ch
Data rejestracji: 2005-11-07
Ilość postów: 23259

1386
wpis nr 1 289 051
[ CZCIONKA MONOSPACE ]

Ten mały Bit ,może być nośnikiem informacji,
ale trzeba mieć z tym jakieś obycie
Muszę zapewne ....iść na kurs.
2020-04-29 (12:43)

status 777ch
Data rejestracji: 2005-11-07
Ilość postów: 23259

1386
wpis nr 1 289 056
[ CZCIONKA MONOSPACE ]

fair_play

Zapewne zaliczasz dodatkową drzemkę

sądzę ,że tablice wielowymiarowe,choć pamięciożerne
to ....jednak rozwiązanie superszybkie ,bo to właściwie
operacje wypełnienia na bazie linii coveru
a potem tylko policzenie pustych

Twoja wiedza w temacie bitów ,może pozwoli Ci
na uzyskanie podobnych czasów,
bez drastycznego obciążania pamięci....
co na pewno jest interesujące,
ja w temacie bitów jestem
jak winda... na poziomie "0"

miłego dnia,idę [drugi raz] z psem,
potem kawa

--- wpis edytowano 2020-04-29 12:44 ---

2020-04-29 (13:10)

status fair_play
Data rejestracji: 2016-05-12
Ilość postów: 9076

14865
wpis nr 1 289 058
[ CZCIONKA MONOSPACE ]

777ch>
Gdyby zrezygnować z obliczania krotności występowania danej szóstki w rozpisie,a pozostać tylko przy sprawdzaniu jej występowania to Excelowską zabawę z bitami można by zorganizować tak (dla uproszczenia przedstawię ideę na małych liczbach ) :

Powiedzmy że mamy do dyspozycji 800 000 pamięci i tworzymy dwubajtową (16 bitów) tablicę adresów o tym rozmiarze. Tym sposobem mamy do dyspozycji 800 000 * 16 = 12 800 000 dostępnych adresów.

Jak zapisać w niej adr6=2 345 678 ?

Obliczamy wiersz matrycy n= QUOTIENT(2 345 678:800 000), n=2 czyli zapiszemy szóstkę w drugim wierszu matrycy (na drugim bicie).

A na jakiej pozycji ? wyliczamy ją jako adres=MOD(adr6:800 000) -> adres=745 678
I teraz cała zabawa

Ponieważ nie dysponujemy binarnym OR musimy go spreparować.
Pod wyliczonym adresem 745 687 dodajemy wartość 2^(n-1) -> tzn 1 w pierwszym wierszu, 2 w drugim, 4 w trzecim, 8 w czwartym itd

Ale najpierw musimy sprawdzić czy już tam nie dodaliśmy tej wartości (nie zarejestrowaliśmy już takiej "szóstki").

I tutaj cały problem jak to sprawdzić. Jeszcze nie wymyśliłem

Może dodawać 2^(n-1) +1 żeby nie była to wielokrotność 2 ?

Popróbuję

Pozdrawiam

--- wpis edytowano 2020-04-29 13:20 ---

2020-04-29 (13:31)

status 777ch
Data rejestracji: 2005-11-07
Ilość postów: 23259

1386
wpis nr 1 289 061
[ CZCIONKA MONOSPACE ]

Piszesz ciekawie ..pisz dalej

musimy sprawdzić czy już tam nie dodaliśmy tej wartości (nie zarejestrowaliśmy już takiej "szóstki"

no a zapytanie pod adres to już operacja i ułamki czasu

jadę do sklepu ..... proza życia
2020-04-29 (13:43)

status fair_play
Data rejestracji: 2016-05-12
Ilość postów: 9076

14865
wpis nr 1 289 065
[ CZCIONKA MONOSPACE ]

No właśnie w tym cały problem.
Operatory binarne AND i OR zwracają wartość liczbową a nie logiczną "True, False".
Np 7 AND 8 = 0, a 7 AND 10 = 2
7 OR 8 = 15, a 7 OR 3 = 7
oczywiście podane tytaj "liczby" są traktowane dwójkowp:
7 > 0000|0111
8 > 0000|1000
operator AND (iloczyn binarny) "mnoży" poszczególne bity (sprawdza czy na danej pozycji w obu porównywanych wartościach oba bity są ustawione (1), a więc w efekcie otrzymamy 0000|0000
operator OR (suma binarna) "porównuje" bity na określonych pozycjach więc wystarczy że dany bit chociaż w jednej wartości jest ustawiony to jest on ustawiony i w sumie. Dlatego 7 OR 8 => 0000|0111 OR 0000|1000 = 0000|1111 = 15

Lubiłem tę zabawę

--- wpis edytowano 2020-04-29 14:00 ---

2020-04-29 (14:19)

status 777ch
Data rejestracji: 2005-11-07
Ilość postów: 23259

1386
wpis nr 1 289 080
[ CZCIONKA MONOSPACE ]

fair_play

aby manipulować trzeba mieć w jednym paluszku
wiedzę o tym .....co i czym chcesz.....manipulować
próbuj ,a......może się uda !

pozdrawiam
2020-04-29 (14:28)

status 777ch
Data rejestracji: 2005-11-07
Ilość postów: 23259

1386
wpis nr 1 289 087
[ CZCIONKA MONOSPACE ]

zobacz dwie wersje........

function ReverseBits(b: Byte): Byte;
var
i: Integer;
begin
Result := 0;
for i := 1 to 8 do
begin
Result := (Result shl 1) or (b and 1);
b := b shr 1;
end;
end;


But a lookup table would be much more efficient, and only consume 256 bytes of memory.

function ReverseBits(b: Byte): Byte; inline;
const
Table: array [Byte] of Byte = (
0,128,64,192,32,160,96,224,16,144,80,208,48,176,112,240,
8,136,72,200,40,168,104,232,24,152,88,216,56,184,120,248,
4,132,68,196,36,164,100,228,20,148,84,212,52,180,116,244,
12,140,76,204,44,172,108,236,28,156,92,220,60,188,124,252,
2,130,66,194,34,162,98,226,18,146,82,210,50,178,114,242,
10,138,74,202,42,170,106,234,26,154,90,218,58,186,122,250,
6,134,70,198,38,166,102,230,22,150,86,214,54,182,118,246,
14,142,78,206,46,174,110,238,30,158,94,222,62,190,126,254,
1,129,65,193,33,161,97,225,17,145,81,209,49,177,113,241,
9,137,73,201,41,169,105,233,25,153,89,217,57,185,121,249,
5,133,69,197,37,165,101,229,21,149,85,213,53,181,117,245,
13,141,77,205,45,173,109,237,29,157,93,221,61,189,125,253,
3,131,67,195,35,163,99,227,19,147,83,211,51,179,115,243,
11,139,75,203,43,171,107,235,27,155,91,219,59,187,123,251,
7,135,71,199,39,167,103,231,23,151,87,215,55,183,119,247,
15,143,79,207,47,175,111,239,31,159,95,223,63,191,127,255
);
begin
Result := Table[b];
end;
This is more than 10 times faster than the version of the code that operates on individual bits.
2020-04-29 (14:44)

status fair_play
Data rejestracji: 2016-05-12
Ilość postów: 9076

14865
wpis nr 1 289 091
[ CZCIONKA MONOSPACE ]

Nie bardzo rozumiem co robi druga z funkcji pomiędzy begin i end.
Co to za operacja: Result:= Table[b] ?
Przecież to chyba zwykłe podstawienie.
I co otrzymamy w efekcie ?

--- wpis edytowano 2020-04-29 14:51 ---

2020-04-29 (14:53)

status 777ch
Data rejestracji: 2005-11-07
Ilość postów: 23259

1386
wpis nr 1 289 092
[ CZCIONKA MONOSPACE ]

zadałem sam sobie to pytanie
już po wklejeniu
https://stackoverflow.com/questions/14400845/how-can-i-bit-reflect-a-byte-in-delphi
2020-04-29 (15:13)

status 777ch
Data rejestracji: 2005-11-07
Ilość postów: 23259

1386
wpis nr 1 289 101
[ CZCIONKA MONOSPACE ]


funkcja reverse dla zapytania 0 zwraca: 0
funkcja reverse dla zapytania 1 zwraca: 128
funkcja reverse dla zapytania 2 zwraca: 64
funkcja reverse dla zapytania 3 zwraca: 192
funkcja reverse dla zapytania 4 zwraca: 32
funkcja reverse dla zapytania 5 zwraca: 160
funkcja reverse dla zapytania 6 zwraca: 96
funkcja reverse dla zapytania 7 zwraca: 224
funkcja reverse dla zapytania 8 zwraca: 16
funkcja reverse dla zapytania 9 zwraca: 144
funkcja reverse dla zapytania 10 zwraca: 80
funkcja reverse dla zapytania 11 zwraca: 208
funkcja reverse dla zapytania 12 zwraca: 48
funkcja reverse dla zapytania 13 zwraca: 176
funkcja reverse dla zapytania 14 zwraca: 112
funkcja reverse dla zapytania 15 zwraca: 240
funkcja reverse dla zapytania 16 zwraca: 8
funkcja reverse dla zapytania 17 zwraca: 136
funkcja reverse dla zapytania 18 zwraca: 72
funkcja reverse dla zapytania 19 zwraca: 200
funkcja reverse dla zapytania 20 zwraca: 40
funkcja reverse dla zapytania 21 zwraca: 168
funkcja reverse dla zapytania 22 zwraca: 104
funkcja reverse dla zapytania 23 zwraca: 232
funkcja reverse dla zapytania 24 zwraca: 24
funkcja reverse dla zapytania 25 zwraca: 152
funkcja reverse dla zapytania 26 zwraca: 88
funkcja reverse dla zapytania 27 zwraca: 216
funkcja reverse dla zapytania 28 zwraca: 56
funkcja reverse dla zapytania 29 zwraca: 184
funkcja reverse dla zapytania 30 zwraca: 120
funkcja reverse dla zapytania 31 zwraca: 248
funkcja reverse dla zapytania 32 zwraca: 4
funkcja reverse dla zapytania 33 zwraca: 132
funkcja reverse dla zapytania 34 zwraca: 68
funkcja reverse dla zapytania 35 zwraca: 196
funkcja reverse dla zapytania 36 zwraca: 36
funkcja reverse dla zapytania 37 zwraca: 164
funkcja reverse dla zapytania 38 zwraca: 100
funkcja reverse dla zapytania 39 zwraca: 228
funkcja reverse dla zapytania 40 zwraca: 20
funkcja reverse dla zapytania 41 zwraca: 148
funkcja reverse dla zapytania 42 zwraca: 84
funkcja reverse dla zapytania 43 zwraca: 212
funkcja reverse dla zapytania 44 zwraca: 52
funkcja reverse dla zapytania 45 zwraca: 180
funkcja reverse dla zapytania 46 zwraca: 116
funkcja reverse dla zapytania 47 zwraca: 244
funkcja reverse dla zapytania 48 zwraca: 12
funkcja reverse dla zapytania 49 zwraca: 140
funkcja reverse dla zapytania 50 zwraca: 76
funkcja reverse dla zapytania 51 zwraca: 204
funkcja reverse dla zapytania 52 zwraca: 44
funkcja reverse dla zapytania 53 zwraca: 172
funkcja reverse dla zapytania 54 zwraca: 108
funkcja reverse dla zapytania 55 zwraca: 236
funkcja reverse dla zapytania 56 zwraca: 28
funkcja reverse dla zapytania 57 zwraca: 156
funkcja reverse dla zapytania 58 zwraca: 92
funkcja reverse dla zapytania 59 zwraca: 220
funkcja reverse dla zapytania 60 zwraca: 60
funkcja reverse dla zapytania 61 zwraca: 188
funkcja reverse dla zapytania 62 zwraca: 124
funkcja reverse dla zapytania 63 zwraca: 252
funkcja reverse dla zapytania 64 zwraca: 2
funkcja reverse dla zapytania 65 zwraca: 130
funkcja reverse dla zapytania 66 zwraca: 66
funkcja reverse dla zapytania 67 zwraca: 194
funkcja reverse dla zapytania 68 zwraca: 34
funkcja reverse dla zapytania 69 zwraca: 162
funkcja reverse dla zapytania 70 zwraca: 98
funkcja reverse dla zapytania 71 zwraca: 226
funkcja reverse dla zapytania 72 zwraca: 18
funkcja reverse dla zapytania 73 zwraca: 146
funkcja reverse dla zapytania 74 zwraca: 82
funkcja reverse dla zapytania 75 zwraca: 210
funkcja reverse dla zapytania 76 zwraca: 50
funkcja reverse dla zapytania 77 zwraca: 178
funkcja reverse dla zapytania 78 zwraca: 114
funkcja reverse dla zapytania 79 zwraca: 242
funkcja reverse dla zapytania 80 zwraca: 10
funkcja reverse dla zapytania 81 zwraca: 138
funkcja reverse dla zapytania 82 zwraca: 74
funkcja reverse dla zapytania 83 zwraca: 202
funkcja reverse dla zapytania 84 zwraca: 42
funkcja reverse dla zapytania 85 zwraca: 170
funkcja reverse dla zapytania 86 zwraca: 106
funkcja reverse dla zapytania 87 zwraca: 234
funkcja reverse dla zapytania 88 zwraca: 26
funkcja reverse dla zapytania 89 zwraca: 154
funkcja reverse dla zapytania 90 zwraca: 90
funkcja reverse dla zapytania 91 zwraca: 218
funkcja reverse dla zapytania 92 zwraca: 58
funkcja reverse dla zapytania 93 zwraca: 186
funkcja reverse dla zapytania 94 zwraca: 122
funkcja reverse dla zapytania 95 zwraca: 250
funkcja reverse dla zapytania 96 zwraca: 6
funkcja reverse dla zapytania 97 zwraca: 134
funkcja reverse dla zapytania 98 zwraca: 70
funkcja reverse dla zapytania 99 zwraca: 198
funkcja reverse dla zapytania 100 zwraca: 38
funkcja reverse dla zapytania 101 zwraca: 166
funkcja reverse dla zapytania 102 zwraca: 102
funkcja reverse dla zapytania 103 zwraca: 230
funkcja reverse dla zapytania 104 zwraca: 22
funkcja reverse dla zapytania 105 zwraca: 150
funkcja reverse dla zapytania 106 zwraca: 86
funkcja reverse dla zapytania 107 zwraca: 214
funkcja reverse dla zapytania 108 zwraca: 54
funkcja reverse dla zapytania 109 zwraca: 182
funkcja reverse dla zapytania 110 zwraca: 118
funkcja reverse dla zapytania 111 zwraca: 246
funkcja reverse dla zapytania 112 zwraca: 14
funkcja reverse dla zapytania 113 zwraca: 142
funkcja reverse dla zapytania 114 zwraca: 78
funkcja reverse dla zapytania 115 zwraca: 206
funkcja reverse dla zapytania 116 zwraca: 46
funkcja reverse dla zapytania 117 zwraca: 174
funkcja reverse dla zapytania 118 zwraca: 110
funkcja reverse dla zapytania 119 zwraca: 238
funkcja reverse dla zapytania 120 zwraca: 30
funkcja reverse dla zapytania 121 zwraca: 158
funkcja reverse dla zapytania 122 zwraca: 94
funkcja reverse dla zapytania 123 zwraca: 222
funkcja reverse dla zapytania 124 zwraca: 62
funkcja reverse dla zapytania 125 zwraca: 190
funkcja reverse dla zapytania 126 zwraca: 126
funkcja reverse dla zapytania 127 zwraca: 254
funkcja reverse dla zapytania 128 zwraca: 1
funkcja reverse dla zapytania 129 zwraca: 129
funkcja reverse dla zapytania 130 zwraca: 65
funkcja reverse dla zapytania 131 zwraca: 193
funkcja reverse dla zapytania 132 zwraca: 33
funkcja reverse dla zapytania 133 zwraca: 161
funkcja reverse dla zapytania 134 zwraca: 97
funkcja reverse dla zapytania 135 zwraca: 225
funkcja reverse dla zapytania 136 zwraca: 17
funkcja reverse dla zapytania 137 zwraca: 145
funkcja reverse dla zapytania 138 zwraca: 81
funkcja reverse dla zapytania 139 zwraca: 209
funkcja reverse dla zapytania 140 zwraca: 49
funkcja reverse dla zapytania 141 zwraca: 177
funkcja reverse dla zapytania 142 zwraca: 113
funkcja reverse dla zapytania 143 zwraca: 241
funkcja reverse dla zapytania 144 zwraca: 9
funkcja reverse dla zapytania 145 zwraca: 137
funkcja reverse dla zapytania 146 zwraca: 73
funkcja reverse dla zapytania 147 zwraca: 201
funkcja reverse dla zapytania 148 zwraca: 41
funkcja reverse dla zapytania 149 zwraca: 169
funkcja reverse dla zapytania 150 zwraca: 105
funkcja reverse dla zapytania 151 zwraca: 233
funkcja reverse dla zapytania 152 zwraca: 25
funkcja reverse dla zapytania 153 zwraca: 153
funkcja reverse dla zapytania 154 zwraca: 89
funkcja reverse dla zapytania 155 zwraca: 217
funkcja reverse dla zapytania 156 zwraca: 57
funkcja reverse dla zapytania 157 zwraca: 185
funkcja reverse dla zapytania 158 zwraca: 121
funkcja reverse dla zapytania 159 zwraca: 249
funkcja reverse dla zapytania 160 zwraca: 5
funkcja reverse dla zapytania 161 zwraca: 133
funkcja reverse dla zapytania 162 zwraca: 69
funkcja reverse dla zapytania 163 zwraca: 197
funkcja reverse dla zapytania 164 zwraca: 37
funkcja reverse dla zapytania 165 zwraca: 165
funkcja reverse dla zapytania 166 zwraca: 101
funkcja reverse dla zapytania 167 zwraca: 229
funkcja reverse dla zapytania 168 zwraca: 21
funkcja reverse dla zapytania 169 zwraca: 149
funkcja reverse dla zapytania 170 zwraca: 85
funkcja reverse dla zapytania 171 zwraca: 213
funkcja reverse dla zapytania 172 zwraca: 53
funkcja reverse dla zapytania 173 zwraca: 181
funkcja reverse dla zapytania 174 zwraca: 117
funkcja reverse dla zapytania 175 zwraca: 245
funkcja reverse dla zapytania 176 zwraca: 13
funkcja reverse dla zapytania 177 zwraca: 141
funkcja reverse dla zapytania 178 zwraca: 77
funkcja reverse dla zapytania 179 zwraca: 205
funkcja reverse dla zapytania 180 zwraca: 45
funkcja reverse dla zapytania 181 zwraca: 173
funkcja reverse dla zapytania 182 zwraca: 109
funkcja reverse dla zapytania 183 zwraca: 237
funkcja reverse dla zapytania 184 zwraca: 29
funkcja reverse dla zapytania 185 zwraca: 157
funkcja reverse dla zapytania 186 zwraca: 93
funkcja reverse dla zapytania 187 zwraca: 221
funkcja reverse dla zapytania 188 zwraca: 61
funkcja reverse dla zapytania 189 zwraca: 189
funkcja reverse dla zapytania 190 zwraca: 125
funkcja reverse dla zapytania 191 zwraca: 253
funkcja reverse dla zapytania 192 zwraca: 3
funkcja reverse dla zapytania 193 zwraca: 131
funkcja reverse dla zapytania 194 zwraca: 67
funkcja reverse dla zapytania 195 zwraca: 195
funkcja reverse dla zapytania 196 zwraca: 35
funkcja reverse dla zapytania 197 zwraca: 163
funkcja reverse dla zapytania 198 zwraca: 99
funkcja reverse dla zapytania 199 zwraca: 227
funkcja reverse dla zapytania 200 zwraca: 19
funkcja reverse dla zapytania 201 zwraca: 147
funkcja reverse dla zapytania 202 zwraca: 83
funkcja reverse dla zapytania 203 zwraca: 211
funkcja reverse dla zapytania 204 zwraca: 51
funkcja reverse dla zapytania 205 zwraca: 179
funkcja reverse dla zapytania 206 zwraca: 115
funkcja reverse dla zapytania 207 zwraca: 243
funkcja reverse dla zapytania 208 zwraca: 11
funkcja reverse dla zapytania 209 zwraca: 139
funkcja reverse dla zapytania 210 zwraca: 75
funkcja reverse dla zapytania 211 zwraca: 203
funkcja reverse dla zapytania 212 zwraca: 43
funkcja reverse dla zapytania 213 zwraca: 171
funkcja reverse dla zapytania 214 zwraca: 107
funkcja reverse dla zapytania 215 zwraca: 235
funkcja reverse dla zapytania 216 zwraca: 27
funkcja reverse dla zapytania 217 zwraca: 155
funkcja reverse dla zapytania 218 zwraca: 91
funkcja reverse dla zapytania 219 zwraca: 219
funkcja reverse dla zapytania 220 zwraca: 59
funkcja reverse dla zapytania 221 zwraca: 187
funkcja reverse dla zapytania 222 zwraca: 123
funkcja reverse dla zapytania 223 zwraca: 251
funkcja reverse dla zapytania 224 zwraca: 7
funkcja reverse dla zapytania 225 zwraca: 135
funkcja reverse dla zapytania 226 zwraca: 71
funkcja reverse dla zapytania 227 zwraca: 199
funkcja reverse dla zapytania 228 zwraca: 39
funkcja reverse dla zapytania 229 zwraca: 167
funkcja reverse dla zapytania 230 zwraca: 103
funkcja reverse dla zapytania 231 zwraca: 231
funkcja reverse dla zapytania 232 zwraca: 23
funkcja reverse dla zapytania 233 zwraca: 151
funkcja reverse dla zapytania 234 zwraca: 87
funkcja reverse dla zapytania 235 zwraca: 215
funkcja reverse dla zapytania 236 zwraca: 55
funkcja reverse dla zapytania 237 zwraca: 183
funkcja reverse dla zapytania 238 zwraca: 119
funkcja reverse dla zapytania 239 zwraca: 247
funkcja reverse dla zapytania 240 zwraca: 15
funkcja reverse dla zapytania 241 zwraca: 143
funkcja reverse dla zapytania 242 zwraca: 79
funkcja reverse dla zapytania 243 zwraca: 207
funkcja reverse dla zapytania 244 zwraca: 47
funkcja reverse dla zapytania 245 zwraca: 175
funkcja reverse dla zapytania 246 zwraca: 111
funkcja reverse dla zapytania 247 zwraca: 239
funkcja reverse dla zapytania 248 zwraca: 31
funkcja reverse dla zapytania 249 zwraca: 159
funkcja reverse dla zapytania 250 zwraca: 95
funkcja reverse dla zapytania 251 zwraca: 223
funkcja reverse dla zapytania 252 zwraca: 63
funkcja reverse dla zapytania 253 zwraca: 191
funkcja reverse dla zapytania 254 zwraca: 127
funkcja reverse dla zapytania 255 zwraca: 255


wszystko jak w tablicy

--- wpis edytowano 2020-04-29 15:19 ---

2020-04-29 (15:23)

status fair_play
Data rejestracji: 2016-05-12
Ilość postów: 9076

14865
wpis nr 1 289 104
[ CZCIONKA MONOSPACE ]

No to znaczy że tablica jest rezultatem pierwszej z funkcji dla kolejnych liczb, a na niej już nie wykonuje się żadnych operacji. Spróbuję rozgryźć jaką operację realizuje pierwsza z funkcji
2020-04-29 (15:29)

status 777ch
Data rejestracji: 2005-11-07
Ilość postów: 23259

1386
wpis nr 1 289 105
[ CZCIONKA MONOSPACE ]

to samo copowyżej

a ta poniżej

function BitFlip(B: Byte): Byte;
const
N: array[0..15] of Byte = (0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15);
begin
Result := N[B div 16] or N[B mod 16] shl 4;
end;

też to samo ......zwraca numer
funkcja BitFlip dla zapytania 0 zwraca: 0
funkcja BitFlip dla zapytania 1 zwraca: 128
funkcja BitFlip dla zapytania 2 zwraca: 64
funkcja BitFlip dla zapytania 3 zwraca: 192
funkcja BitFlip dla zapytania 4 zwraca: 32
funkcja BitFlip dla zapytania 5 zwraca: 160
funkcja BitFlip dla zapytania 6 zwraca: 96
funkcja BitFlip dla zapytania 7 zwraca: 224
funkcja BitFlip dla zapytania 8 zwraca: 16
funkcja BitFlip dla zapytania 9 zwraca: 144
funkcja BitFlip dla zapytania 10 zwraca: 80

i tak dalej to samo .....
2020-04-29 (15:53)

status 777ch
Data rejestracji: 2005-11-07
Ilość postów: 23259

1386
wpis nr 1 289 108
[ CZCIONKA MONOSPACE ]

function IsBitSet(const val: Longint; const TheBit: Byte): Boolean;
begin
Result := (val and (1 shl TheBit)) <> 0;
end;

function BitOn(const val: Longint; const TheBit: Byte): Longint;
begin
Result := val or (1 shl TheBit);
end;

function BitOff(const val: Longint; const TheBit: Byte): Longint;
begin
Result := val and ((1 shl TheBit) xor $FFFFFFFF);
end;

function BitToggle(const val: Longint; const TheBit: Byte): Longint;
begin
Result := val xor (1 shl TheeBit);
end;


mozliwe że w excelu to się da

ale teraz muszę sie zajać czymś innym
do wieczora.........

źródło
https://www.swissdelphicenter.ch/en/showcode.php?id=1341

--- wpis edytowano 2020-04-29 15:53 ---

| Dodaj wpis w tym temacie | Spis tematów | Wyniki lottoStrona: 1 2 ... 324 325 326 ... 561 562

Wyślij wiadomość do admina
🎱 MultiPairs 2027 – nowa wersja w przeglądarce, otwórz BETA