(zainspirowany tym postem na łamigłówkach. PRZESTROGA: SPOILERY DLA TEJ PUZZLE SĄ PONIŻEJ).

Standardowa klawiatura telefoniczna koreluje litery z cyframi w następujący sposób:

1 ->
2 -> ABC
3 -> DEF
4 -> GHI
5 -> JKL
6 -> MNO
7 -> PQRS
8 -> TUV
9 -> WXYZ
0 ->

Dane słowo wejściowe jest definiowane jako Słowo Uporządkowane, jeśli po przetłumaczeniu na naciśnięcia klawiatury za pomocą powyższego, wynikowa liczba nie zmniejsza się lub nie rośnie. Innymi słowy, wynikowa liczba nie może zarówno zwiększać, jak i zmniejszać.

Na przykład słowo to CATtłumaczy się na słowo 228, które nie maleje, a zatem Słowo uporządkowane. Jednak słowo DOGto 364, które zarówno wzrasta, jak i maleje, a zatem nie jest Słowem uporządkowanym.

Wyzwanie

Biorąc pod uwagę słowo, wypisz, czy jest to Uporządkowane, czy nie.

Wkład

• Słowo (niekoniecznie słowo słownikowe) składające się wyłącznie z alfabetu ASCII ( [A-Z]lub [a-z]), w dowolnym odpowiednim formacie .
• Twój wybór, jeśli dane wejściowe są pisane wielkimi lub małymi literami, ale muszą być spójne.
• Słowo będzie miało co najmniej 3 znaki.

Wydajność

Spójne truthy / falsey wart, czy słowo wejściowe jest zamawiany (truthy) lub nie zamówione (falsey).

Zasady

• Dopuszczalny jest pełny program lub funkcja. Jeśli funkcja, możesz zwrócić dane wyjściowe zamiast je wydrukować.
• Jeśli to możliwe, dołącz link do internetowego środowiska testowego, aby inni mogli wypróbować Twój kod!
• Standardowe luki są zabronione.
• To jest golf golfowy, więc obowiązują wszystkie zwykłe zasady gry w golfa, a wygrywa najkrótszy kod (w bajtach).

Przykłady

Oto kilka uporządkowanych słów (tzn. Prawdomównych), a więcej na temat powiązanych łamigłówek.

CAT
TAC
AAA
DEMONS
SKID
LKJONMSRQP
ABCDEFGHIJKLMNOPQRSTUVWXYZ

Oto kilka słów nieuporządkowanych (np. Falsey)

DOG
GOD
ROSE
COFFEE
JKLMNOGHI

Python 2 , 164 148 132 77 bajtów

-16 bajtów dzięki sugestii Roda w innym miejscu . Cholera - 55 bajtów dzięki Arnoldowi Palmerowi.

n=[min(int((ord(i)-58)/3.13),9)for i in input()]
print sorted(n)in[n,n[::-1]]

Wypróbuj online!

Dane wejściowe muszą być pisane wielkimi literami. Wyjścia Truelub Falsena podstawie ich uporządkowania.

Wyjaśnienie

Pierwszy wiersz odwzorowuje każdą literę na liczbę.

                               for i in input()   # iterate over the input string
            ord(i)                                # take the ASCII ordinal
                  -58                             # subtract 58
           (         )/3.13                       # divide by 3.13
       int(                )                      # chop off the fractional part
   min(                     ,9)                   # choose the minimum between the number and 9
n=[                                            ]  # assign the resulting list to n

Działa to w oparciu o:

          | A   B   C  | D   E   F  | G   H   I  | J   K   L  | M   N   O  | P   Q   R   S  | T   U   V  | W   X   Y   Z
----------+------------+------------+------------+------------+------------+----------------+------------+-----------------
ord(x)    | 65  66  67 | 68  69  70 | 71  72  73 | 74  75  76 | 77  78  79 | 80  81  82  83 | 84  85  86 | 87  88  89  90
----------+------------+------------+------------+------------+------------+----------------+------------+-----------------
x - 58    | 7   8   9  | 10  11  12 | 13  14  15 | 16  17  18 | 19  20  21 | 22  23  24  25 | 26  27  28 | 29  30  31  32
----------+------------+------------+------------+------------+------------+----------------+------------+-----------------
x ÷ 3.13* | 2.2 2.6 2.9| 3.2 3.5 3.8| 4.2 4.5 4.8| 5.1 5.4 5.8| 6.1 6.4 6.7| 7.0 7.3 7.7 7.9| 8.3 8.6 8.9| 9.3 9.6 9.9 10.2
----------+------------+------------+------------+------------+------------+----------------+------------+-----------------
int(x)    | 2   2   2  | 3   3   3  | 4   4   4  | 5   5   5  | 6   6   6  | 7   7   7   7  | 8   8   8  | 9   9   9   10
----------+------------+------------+------------+------------+------------+----------------+------------+-----------------
min(x, 9) | 2   2   2  | 3   3   3  | 4   4   4  | 5   5   5  | 6   6   6  | 7   7   7   7  | 8   8   8  | 9   9   9   9

_{* Wartości są zaokrąglone. : P}

Drugi wiersz jest wyprowadzany, jeśli lista liczb jest w porządku rosnącym lub malejącym.

print                                             # print whether...
      sorted(n)                                   # n sorted...
               in[n,n[::-1]]                      # is equivalent to n or n reversed

JavaScript (ES6),  83 ... 71  70 bajtów

Zwraca wartość logiczną.

x=>[...x].every(c=>v&=~(k=x,x=parseInt(c,35)*.32|0||10,x<k?2:x>k),v=3)

Przypadki testowe

let f =

x=>[...x].every(c=>v&=~(k=x,x=parseInt(c,35)*.32|0||10,x<k?2:x>k),v=3)

test = a => a.forEach(s => console.log(f(s) + " for '" + s + "'"))

console.log('[Truthy]')
test(["AAA", "CAT", "TAC", "DEMONS", "SKID", "LKJONMSRQP", "ABCDEFGHIJKLMNOPQRSTUVWXYZ"])

console.log('[Falsy]')
test(["DOG", "GOD", "ROSE", "COFFEE", "JKLMNOGHI"])

W jaki sposób?

Konwersja liter

Używamy parseInt(c, 35)do konwersji każdej litery ciągu wejściowego na pewną liczbę w [ 10 .. 34 ]. Ponieważ jest to base-35, zamiast tego konwertowane jest „Z”NaN .

Wyrażenie * .32 | 0odwzorowuje tę liczbę na przedział [ 3 .. 10 ], prowadząc do 8 poprawnych grup liter dla „A” do „Y” . Musimy || 10uzyskać prawidłową wartość dla „Z” .

           | A  B  C| D  E  F| G  H  I| J  K  L| M  N  O| P  Q  R  S| T  U  V| W  X  Y   Z
-----------+--------+--------+--------+--------+--------+-----------+--------+------------
parseInt   |10 11 12|13 14 15|16 17 18|19 20 21|22 23 24|25 26 27 28|29 30 31|32 33 34 NaN
-----------+--------+--------+--------+--------+--------+-----------+--------+------------
*.32|0||10 | 3  3  3| 4  4  4| 5  5  5| 6  6  6| 7  7  7| 8  8  8  8| 9  9  9|10 10 10  10

Zamów test

Śledzimy oznaki różnic między kolejnymi liczbami w masce bitów v , początkowo ustawionej na 3 (0b11):

• bit # 0: wyczyszczony, gdy nowa_wartość> poprzednia_wartość
• bit nr 1: wyczyszczony, gdy nowa_wartość <poprzednia_wartość

Poprzednia wartość jest przechowywana w tej samej zmiennej x co dane wejściowe. Zapewnia to, że pierwsza iteracja - tam, gdzie faktycznie nie istnieje żadna poprzednia wartość - nie zostanie skasowana, ponieważ łańcuch zawierający tylko litery nie jest ani większy, ani mniejszy niż dowolna liczba:

('CAT' > 5) === false
('CAT' < 5) === false

Słowo jest uporządkowane, chyba że napotkane zostaną oba znaki, co prowadzi do v = 0 i powoduje every()błąd.

Galaretka , 28, 27, 25, 23, 22, 21, 19, 18 bajtów

_>
O‘ç82ç88:3IṠḟ0E

Wypróbuj online!

Pisanie to była świetna zabawa!

Wyjaśnienie:

                # Define a helper link, decrement a if a > b
_               # Subtract
 >              # Boolean greater than
                # Main link:
O               # The ordinals (ASCII points) of the input
 ‘              # Minus one
  ç82           # Decrement if greater than 82
     ç88        # Decrement if greater than 88
        :3      # Divide each number by 3
          I     # Consecutive differences
           Ṡ    # Sign (-1 if < 0, 0 if == 0, and 1 if > 0)
            ḟ0  # Remove all 0's
              E # All elements are equal?

Dzięki @ErikTheOutgolfer, @leakynun i @BusinessCat za wszystkie zapisane bajty. :)

05AB1E , 36 bajtów

v.•1нJ©½è`ÇHø¹á₂N¸°…ÈáÀ•#Dʒyå}k}¥0‹Ë

Wypróbuj online!

MATL , 26 25 bajtów

1Y21K250B-Y{c&m8\dZSu|s2<

Wprowadzanie odbywa się dużymi literami. Dane wyjściowe to 1lub 0.

Wypróbuj online!

Wyjaśnienie

1Y2      % Push 'ABC...XYZ'
1        % Push 1
K        % Push 4
250B     % Push 250 in binary, that is, [1 1 1 1 1 0 1 0]
-        % Subtract (from 4, element-wise): gives [3 3 3 3 3 4 1 4]
Y{       % Convert to cell array, splitting into chunks of those lengths
c        % Convert to char matrix. Gives a 4-column matrix. Chunks of length 3
         % are right-padded with a space
&m       % Implicit input. Push (linear) index of membership in char matrix
8\       % Modulo 8. Converts linear index into 0-based row index
d        % Consecutive differences
ZS       % Sign
u        % Unique
|        % Absolute value
s        % Sum
2<       % Less than 2? Implicit display

Łuska , 22 21 19 18 bajtów

±S€Ẋ▲`Ṫo±≤"DGJMPTW

Zwraca 1za prawdziwe dane, 0za fałszywe. Dane wejściowe muszą być pisane wielkimi literami. Przechodzi wszystkie przypadki testowe. Wypróbuj online!

Wyjaśnienie

±S€Ẋ▲`Ṫo±≤"DGJMPTW  Implicit input x, e.g. "CAT"
     `Ṫo±≤"DGJMPTW  This part transforms x into a "canonical form" corresponding to the numpad digits
     `Ṫ             Table with flipped arguments
       o±≤          on sign of less-than-or-equal
                    (In Husk, ≤ returns extra information we don't want, so we take sign of the result to get 0 or 1.)
          "DGJMPTW  of this string and x.
                    This gives, for each char in x, a bit array of comparisons with the chars in the string:
                    y = [[0,0,0,0,0,0,0],[0,0,0,0,0,0,0],[1,1,1,1,1,1,0]]
   Ẋ▲               Maxima of adjacent pairs: [[0,0,0,0,0,0,0],[1,1,1,1,1,1,0]]
 S€                 1-based index in y as sublist: 2
±                   Sign: 1

Python 2 , 60 bajtów

a=[3681/ord(c)for c in input()]
print sorted(a)in[a,a[::-1]]

Wypróbuj online!

Akceptuje wprowadzanie małymi literami.

Jak to działa

⌊3681 / x ⌋ maleje od

• 38 do 37 przy x ≈ 96,8684210526, przed a;
• 37 do 36 przy x = 99,8664864865, pomiędzy ci d;
• 36 do 35 przy x ≈ 102,25, między fi g;
• 35 do 34 przy x ≈ 105,171428571, między ii j;
• 34 do 33 przy x = 108,264705882, pomiędzy li m;
• 33 do 32 przy x ≈ 111,545454545, między oi p;
• 32 do 31 przy x ≈ 115,03125, między si t;
• 31 do 30 przy x ≈ 118,741935484, między vi w;
• 30 do 29 przy x ≈ 122,7, po z.

C ++, 375 199 195 194 bajtów

Dzięki odpowiedzi Shaggy na JavaScript:
-5 bajtów dzięki Zacharýmu

#include<string>
int o(std::string a){std::string m="22233344455566677778889999";for(auto&b:a)b=m[b-65];int j=1,i=0,d=0;for(;j<a.size();++j){if(a[j]>a[j-1])++i;if(a[j]<a[j-1])++d;}return!(i*d);}

05AB1E , 30 bajtów

A3 8×Ƶ0+S£¹δåā>‚øε`*}.«+¥0K0‹Ë

Wypróbuj online!

-1 dzięki Magic Octopus Urn .

Siatkówka , 65 bajtów

T`_ADGJMPTW`d
}T`L`_L
(.)\1*
$1$*1<
(1+)<(?!\1)
$1>
1

^(<*|>*)>$

Wypróbuj online! Link zawiera przypadki testowe. Wyjaśnienie:

T`_ADGJMPTW`d

Zmień pierwszą literę na każdym przycisku na cyfrę. (Jest to wyłączone o 1, ale to nie ma znaczenia dla czeku rosnącego / malejącego. Z drugiej strony, zera utrudniłyby mi życie, więc zostawiłem jeden znak wypełniający.)

}T`L`_L

Przetasuj wszystkie pozostałe litery w górę o 1 i powtarzaj, aż wszystkie zostaną zamienione na cyfry.

(.)\1*
$1$*1<

Konwertuj cyfry na jednoargumentowe, ale tylko raz na ciąg identycznych cyfr. Jednostkowe wartości są oddzielone <...

(1+)<(?!\1)
$1>

... ale jeśli LHS okaże się większy niż RHS, popraw <to >.

1

Usuń te, 1które nie są już potrzebne.

^(<*|>*)>$

Sprawdź, czy słowo jest uporządkowane. (Końcowy znak >pochodzi od ostatniej cyfry, która zawsze porównuje większą niż pusta spacja po nim).

Pyth , 23 bajty

Jedna z moich pierwszych nietrywialnych odpowiedzi na Pythona! Zaoszczędź 6 bajtów dzięki @LeakyNun. Wstępne rozwiązanie znajduje się poniżej.

/{_BKmhS,9/a58Cd3.13zSK

Pakiet testowy.

Pyth , 29 bajtów

KmhS+9]/-Cd58 3.13w|qKSKqK_SK

Pakiet testowy.

Wyjaśnienie

/{_BKmhS,9/a58Cd3.13zSKQ - Q oznacza oszacowane dane wejściowe i jest niejawne na końcu

 {- deduplikacja
  _ - Odwróć
   B - Bifurcate, Utwórz listę dwóch elementów, [B, A (B)]
    K - Zmienna z automatycznym przypisaniem do:
     mz - Mapuj dane wejściowe:
      hS - Minimum (pierwszy element posortowanej listy)
        , - Utwórz dwuelementową listę [A, B] z tymi elementami:
         9 - Literał liczbowy 9
          / - Podział liczb całkowitych:
           a58Cd - Bezwzględna różnica między 58 a ord (current_element)   
                3.13 - Literał liczbowy 3.13
                    SK - K posortowane
/ Q - Policz wystąpienia danych wejściowych w [K, K [:: - 1]]                

05AB1E , 21 17 bajtów

Kod

A•22ā₂•Sās×J‡Ô¥dË

Wykorzystuje kodowanie 05AB1E .

Wypróbuj online! lub Zweryfikuj wszystkie przypadki testowe!

Wyjaśnienie

A                   # Push the lowercase alphabet
 •22ā₂•             # Push the number 33333434
       S            # Split into an array
        ā           # Get the range of indices [1 .. length]
         s×         # Swap and string multiply
           J        # Join that array
            ‡       # Transliterate

Teraz zasadniczo mapuje następujące litery na następujące liczby:

abcdefghijklmnopqrstuvwxyz
↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
11122233344455566667778888

             Ô      # Remove consecutive duplicates
              ¥     # Compute the delta's of the list
               d    # Check if the number is greater or equal to 0
                Ë   # Check if all elements are the same

JavaScript (ES6), 107 97 95 92 88 85 bajtów

Działa z ciągami o małych i wielkich literach. Zwraca 1za prawdę lub 0falsey.

s=>(s=(a=[...s].map(c=>(parseInt(c,36)-3)/3.13%10|0||9))+"")==a.sort()|s==a.reverse()

• 10 bajtów zaoszczędzonych dzięki Rod .

Spróbuj

o.innerText=(f=
s=>(s=(a=[...s].map(c=>(parseInt(c,36)-3)/3.13%10|0||9))+"")==a.sort()|s==a.reverse()
)(i.value="Cat")
oninput=_=>o.innerText=f(i.value)

<input id=i><pre id=o>

Gaia , 29 27 25 17 bajtów

ċ⟨):“QX’>¦Σ⁻3/⟩¦o

Wypróbuj online!

Wyjaśnienie

ċ                  Turn the input into a list of code points
 ⟨            ⟩¦   Map this block to each code point:
  )                 Increment it
   :                Copy it
    “QX’            Push [81 88]
        >¦          Check if the code point is greater than each of [81 88]
          Σ         Sum the results
           ⁻        Subtract from the code point
            3/      Integer divide the result by 3
                o  Check if the resulting list is in sorted order (increasing or decreasing)

05AB1E , 13 bajtów

ÇÍžq÷8
7:Ô¥dË

Ilekroć widzę pytanie na klawiaturze numerycznej, muszę odpowiedzieć na podstawie pi.

Wypróbuj online lub sprawdź wszystkie przypadki testowe

Ç                    # ASCII code of each letter in the input
 Í                   # add 2
  žq÷                # divide by pi
     8 7:            # replace 8 with 7
         Ô           # remove duplicates
          ¥          # deltas
           d         # each >= 0 ?
            Ë        # are all elements equal?

Galaretka , 32 bajty

“¢Ç⁺H’D0ẋj1œṗØA⁸=€×"€9Ḋ¤Fḟ0Iḟ0ṠE

Wypróbuj online!

C # (.NET Core) , 133 bajty

using System.Linq;q=>{var u=q.Select(c=>(int)((c-58)/3.13));var z=u.Zip(u.Skip(1),(a,b)=>a-b);return!(z.Any(d=>d<0)&z.Any(d=>d>0));};

Wypróbuj online!

Wydaje mi się, że jest miejsce na oszczędzanie, ale C # nie jest zwięzłym językiem, więc może nie. Nie golfowany:

bool Ordered(string word){

    IEnumerable<int> keys = word.Select(character => (int)((character - 58)/3.13)); 
    // convert characters to keypad number

    IEnumerable<int> differences = keys.Zip(keys.Skip(1), (a, b)=> a-b); 
    // difference between consecutive elements

    return !(differences.Any(diff => diff<0) & differences.Any(diff => diff>0)); 
    // false if both positive and negative differences exist
}

W szczególności myślę, że istnieje krótszy sposób na wyrażenie ostatecznej kontroli ważności, być może sposób na powiązanie go z Zip. Znalezienie sposobu wyrażenia Zipbez potrzeby tymczasowego przechowywania Skiprównież by coś uratowało, ale wątpię, żeby było coś bardziej zwięzłego.

Python 3 , 143 147 148 149 130 bajtów

def g(s,f=lambda c:min(int((ord(c)-58)/3.13),9)):x=[f(a)-f(b)for a,b in zip(s,s[1:])];return any(t<0for t in x)*any(t>0for t in x)

Na razie mogę to zrobić najlepiej. Funkcja surowa zamienia literę w liczbę opartą na kodzie ascii. Z pewnością należy wprowadzić pewne ulepszenia. 0 to prawda, 1 to falsey (przepraszam). Zaoszczędź 10 bajtów dzięki Rodowi, kolejne 3 dzięki Mr. Xcoder.

Wypróbuj online!

Python 2 , 111 103 bajtów

-8 bajtów dzięki @Arnold Palmer: nie jest lower()potrzebny

• Pobiera duże litery jako dane wejściowe.

lambda x:sorted(f(x))in[f(x),f(x)[::-1]]
f=lambda x:['22233344455566677778889999'[ord(i)-65]for i in x]

Wypróbuj online!

PHP 7, 98 + 1 95 + 1 84 + 1 bajtów

port golfowy odpowiedzi Arnaulda .

for(;$c=ord($argn[$i]);$v|=$i++?$p>$k?2:$p<$k:0,$p=$k)$k=($c-58)*.32%10?:9;echo$v<3;

akceptuje wielkie litery; puste wyjście dla fałszu, 1dla prawdy.

Uruchom jako potok z -nRlub spróbuj online .

oryginalny post:

for(;$c=$argn[$i++];$p?$a[]=$p<=>$k:0,$p=$k)$k=(ord($c)-58)/3.13-($c>Y)|0;echo min($a)*max($a)>=0;

CJam, 37 31 30 27 bajtów

q{_"SVZY"#g-i3/}%_$_W%](e=g

Wypróbuj online

Oczywiście brzydka wersja jest krótsza ...

q{        e# For each character in string...
_"SVZY"#g e# Get index of that character in "SVZY". Signum that. (returns 1 or 0 if inside string, -1 if not.)
-i3/      e# Subtract value from character (i.e 'Z' becomes 'Y', 'F' becomes 'G'). Convert to int. Integer divide by 3. (this is just how the math works out for proper mapping of characters to phone digits.)
}%
_$_W%]    e# Put mapped string, sorted version, and reverse sorted version in array.
(         e# Pop mapped string from array onto stack.
e=        e# Count occurences of mapped string in array.
g         e# Signum.

C (gcc) , 183 169 153 117 bajtów

#define a(b)(int)fmin(*(b c)/3.2,27)
d(char*c){int r=1,p=1;for(;1<strlen(c);)r&=a()<=a(1+),p&=a()>=a(++);return r|p;}

Wypróbuj online!

Stare rozwiązanie:

#define a(b)(int)((int)(b*.32-17.6)*.9)
d(char*c){int l=~-strlen(c),i=0,r=1,p=1;for(;i<l;++i)r&=a(c[i])<=a(c[i+1]),p&=a(c[l-i])<=a(c[l-i-1]);return r+p;}

Zaoszczędź 8 bajtów dzięki ThePirateBay.

Stare stare rozwiązanie:

d(char*c){char*a="22233344455566677778889999";int l=strlen(c)-1,i=0,r=1,p=1;for(;i<l;++i){if(a[c[i]-65]>a[c[i+1]-65])r=0;if(a[c[l-i]-65]>a[c[l-i-1]-65])p=0;}return r+p;}

Stare stare stare rozwiązanie:

d(char*c){char*a="22233344455566677778889999";int l=strlen(c);int i,r=1,p=1;for(;i<l-1;++i)if(a[c[i]-65]>a[c[i+1]-65])r=0;for(i=l-1;i>0;--i)if(a[c[i]-65]>a[c[i-1]-65])p=0;return r+p;}

TI-Basic, 92 66 bajtów

ΔList(int(seq(inString("BC DEF GHI JKL MNO PQRSTUV WXYZ",sub(Ans,I,1))/4,I,1,length(Ans
0≤min(Ansmax(Ans

Konwertuje każdy znak w ciągu na liczbę całkowitą od 0 do 7 i przyjmuje różnicę między każdym kolejnym elementem; następnie sprawdza, czy minimalne i maksymalne różnice mają ten sam znak (lub jedno z nich to 0).

Zsh , 73 69 57 bajtów

-12 bajtów przy użyciu 3681/codekonwersji @ anders-kaseorg .

for c (${(s::)1})((y=3681/#c,A|=y<p,D|=p&&p<y,p=y,!D|!A))

Wypróbuj online! Wypróbuj online! Wypróbuj online!

Kilka rzeczy, których nadużywamy:

• ((statement,statement,...))jest sekwencją wyrażeń arytmetycznych, która zwraca prawdę, jeśli ostatnia instrukcja jest niezerowa.
• Zwracana wartość pętli jest wartością zwracaną przez ostatnią instrukcję w pętli.
• Arytmetyczne precedensami operatorskie były bardzo miłe dla nas, jak tylko jedna para bez nawiasów były używane. Jeden bajt mógłby zostać zapisany, gdyby był !związany mniej ściśle niż &.
• Nieustawione parametry rozwijają się do rozszerzeń 0arytmetycznych.
• Funkcja, której używamy do mapowania na numer klawiatury to CODE / 3.2 - 18(ze specjalnym przypadkiem Z), ale ponieważ potrzebujemy tylko zmiany między kodami, nie wykonujemy liniowej regulacji.

for c (${(s::)1})           # split into characters
    (( y = #c-90 ? 0^(#c/3.2) : 27,   # this sets y to the keypad number + 18
       A |= y < p,          # set the A flag if we detect it is not ascending
       D |= p && p < y,     # ditto descending, don't compare on first iteration
       p = y,               # save the current character
       !D | !A              # return false if D and A are both set
    ))

Można zapisać 2 bajty, jeśli można zamienić wartości true / falsey.