Wyzwanie

Biorąc pod uwagę niepustą tablicę liczb całkowitych, np .:

[5, 2, 7, 6, 4, 1, 3]

Najpierw podziel ją na tablice, w których żaden element nie jest większy niż poprzedni (tj. Tablice nie rosnąco):

[5, 2] [7, 6, 4, 1] [3]

Następnie odwróć każdą tablicę:

[2, 5] [1, 4, 6, 7] [3]

Na koniec połącz je wszystkie razem:

[2, 5, 1, 4, 6, 7, 3]

To powinno być to, co zwraca program / funkcja. Powtórz tę procedurę wystarczająco dużo razy, a tablica zostanie w pełni posortowana.

Zasady

• Dane wejściowe i wyjściowe mogą być podawane dowolnymi standardowymi metodami i mogą mieć dowolny rozsądny format macierzowy.
• Tablica wejściowa nigdy nie będzie pusta, ale może zawierać negatywy i / lub duplikaty.
• Wartość bezwzględna każdej liczby całkowitej będzie zawsze mniejsza niż 2 ³¹ .

Przypadki testowe

Mam nadzieję, że obejmują one wszystkie przypadki krawędzi:

[1] -> [1]
[1, 1] -> [1, 1]
[1, 2] -> [1, 2]
[2, 1] -> [1, 2]
[2, 3, 1] -> [2, 1, 3]
[2, 1, 3] -> [1, 2, 3]
[2, 1, 2] -> [1, 2, 2]
[2, 1, 1] -> [1, 1, 2]
[3, 1, 1, 2] -> [1, 1, 3, 2]
[3, 2, 1, 2] -> [1, 2, 3, 2]
[3, 1, 2, 2] -> [1, 3, 2, 2]
[1, 3, 2, 2] -> [1, 2, 2, 3]
[1, 0, 5, -234] -> [0, 1, -234, 5]
[1, 0, 1, 0, 1] -> [0, 1, 0, 1, 1]
[1, 2, 3, 4, 5] -> [1, 2, 3, 4, 5]
[5, 4, 3, 2, 1] -> [1, 2, 3, 4, 5]
[2, 1, 5, 4, 3] -> [1, 2, 3, 4, 5]
[2, 3, 1, 5, 4] -> [2, 1, 3, 4, 5]
[5, 1, 4, 2, 3] -> [1, 5, 2, 4, 3]
[5, 2, 7, 6, 4, 1, 3] -> [2, 5, 1, 4, 6, 7, 3]
[-5, -2, -7, -6, -4, -1, -3] -> [-5, -7, -2, -6, -4, -3, -1]
[14, 5, 3, 8, 15, 7, 4, 19, 12, 0, 2, 18, 6, 11, 13, 1, 17, 16, 10, 9] -> [3, 5, 14, 8, 4, 7, 15, 0, 12, 19, 2, 6, 18, 11, 1, 13, 9, 10, 16, 17]

Punktacja

To jest golf golfowy , więc wygrywa najkrótszy kod w bajtach.

JavaScript (ES6), 64 bajty

f=([n,...a],z=[],q=[n,...z])=>a+a?n<a[0]?[...q,...f(a)]:f(a,q):q

Rekursja FTW! Podstawowym wykorzystywanym tutaj algorytmem jest śledzenie bieżącego nie rosnącego przebiegu w tablicy, „zwracanie” go za każdym razem, gdy zostanie znaleziony element rosnący. Robimy to rekurencyjnie, ciągle łącząc wyniki, dopóki nie zabraknie przedmiotów. Tworząc każdy przebieg w odwrotnej kolejności ( [n,...z]zamiast [...z,n]), możemy uniknąć długiego .reverse()bez żadnych kosztów.

Testowy fragment kodu

f=([n,...a],z=[],q=[n,...z])=>a+a?n<a[0]?[...q,...f(a)]:f(a,q):q

g=a=>console.log("Input:",`[${a}]`,"Output:",`[${f(a)}]`)

g([1])
g([1,1])
g([1,2])
g([2,1])
g([3,2,1])
g([3,1,2])
g([3,1,1,2])
g([5,2,7,6,4,1,3])

<input id=I value="5, 2, 7, 6, 4, 1, 3">
<button onclick="g((I.value.match(/\d+/g)||[]).map(Number))">Run</button>

Python 3 , 63 bajty

f=lambda x,*p:x[:1]>p>()and p+f(x)or x and f(x[1:],x[0],*p)or p

Wypróbuj online!

Galaretka , 8 bajtów

Ṁ;<œṗ³UF

Wypróbuj online!

Wyjaśnienie:

Ṁ;         Prepend the list [a1, a2… an] with its maximum.
  <        Elementwise compare this with the original list:
           [max(a) < a1, a1 < a2, …, a(n-1) < an, an]
           The first element is always 0.
   œṗ³     Partition the original list (³) at the indices
           of the non-zero values in the working list.
           (The spurious `an` at the end of the left argument,
           resulting from comparing lists of different sizes,
           is ignored by this operation, thankfully.)
      U    Reverse each part.
       F   Flatten.

JavaScript (ES6), 70 bajtów

Jasne, jest to już pokonane przez odpowiedź ETHproductions , ale to najlepsze, co mogłem wymyślić do tej pory bez korzystania z rekurencji.

a=>a.map((n,i)=>a[x=[...o,...r=[n,...r]],i+1]>n&&(o=x,r=[]),r=o=[])&&x

Uwaga: Inicjowanie obu ri odokładnie tego samego obiektu za pomocą r = o = []może wyglądać jak niebezpieczny pomysł. Ale jest to bezpieczne, ponieważ rjest to natychmiast przypisywane do własnej instancji (zawierającej pierwszy element a) przy pierwszej iteracji z r = [n, ...r].

Przypadki testowe

let f =

a=>a.map((n,i)=>a[x=[...o,...r=[n,...r]],i+1]>n&&(o=x,r=[]),r=o=[])&&x

console.log(JSON.stringify(f([1])));
console.log(JSON.stringify(f([1, 1])));
console.log(JSON.stringify(f([1, 2])));
console.log(JSON.stringify(f([2, 1])));
console.log(JSON.stringify(f([2, 3, 1])));
console.log(JSON.stringify(f([2, 1, 3])));
console.log(JSON.stringify(f([2, 1, 2])));
console.log(JSON.stringify(f([2, 1, 1])));
console.log(JSON.stringify(f([3, 1, 1, 2])));
console.log(JSON.stringify(f([3, 2, 1, 2])));
console.log(JSON.stringify(f([3, 1, 2, 2])));
console.log(JSON.stringify(f([1, 3, 2, 2])));
console.log(JSON.stringify(f([1, 0, 5, -234])));
console.log(JSON.stringify(f([1, 0, 1, 0, 1])));
console.log(JSON.stringify(f([1, 2, 3, 4, 5])));
console.log(JSON.stringify(f([5, 4, 3, 2, 1])));
console.log(JSON.stringify(f([2, 1, 5, 4, 3])));
console.log(JSON.stringify(f([2, 3, 1, 5, 4])));
console.log(JSON.stringify(f([5, 1, 4, 2, 3])));
console.log(JSON.stringify(f([5, 2, 7, 6, 4, 1, 3])));
console.log(JSON.stringify(f([-5, -2, -7, -6, -4, -1, -3])));
console.log(JSON.stringify(f([14, 5, 3, 8, 15, 7, 4, 19, 12, 0, 2, 18, 6, 11, 13, 1, 17, 16, 10, 9])));

MATL , 15 bajtów

lidO>vYsGhXSOZ)

Dane wejściowe to wektor kolumny o formacie [5; 2; 7; 6; 4; 1; 3](średnik jest separatorem wierszy).

Wypróbuj online!

Weź [5; 2; 7; 6; 4; 1; 3]przykład jako przykład.

Wyjaśnienie

l     % Push 1
      % STACK: 1
i     % Push input
      % STACK: 1, [5; 2; 7; 6; 4; 1; 3]
d     % Consecutive differences
      % STACK: 1, [-3; 5; -1; -2; -3; 2]
O>    % Test if greater than 0, element-wise
      % STACK: 1, [0; 1; 0; 0; 0; 1]
v     % Concatenate vertically
      % STACK: [1; 0; 1; 0; 0; 0; 1]
Ys    % Cumulative sum
      % STACK: [1; 1; 2; 2; 2; 2; 3]
G     % Push input again
      % STACK: [1; 1; 2; 2; 2; 2; 3], [5; 2; 7; 6; 4; 1; 3]
h     % Concatenate horizontally
      % STACK: [1 5; 1 2; 2 7; 2 6; 2 4; 2 1; 3 3]
XS    % Sort rows in lexicographical order
      % STACK: [1 2; 1 5; 2 1; 2 4; 2 6; 2 7; 3 3]
OZ)   % Get last column. Implicitly display
      % STACK: [2; 5; 1; 4; 6; 7; 3]

Mathematica, 30 27 bajtów

^{3 bajty zapisane z powodu @Martin Ender .}

Join@@Sort/@Split[#,#>#2&]&

Funkcja anonimowa. Pobiera listę liczb jako dane wejściowe i zwraca listę liczb jako dane wyjściowe.

Python 2, 100 bajtów

Naprawdę okropny golf, ale chciałem opublikować moje rozwiązanie (jeden nie jest po prostu lepszy niż Dennis) ...

d=input();L=[];x=0;d+=-~d[-1],
for i in range(1,len(d)):
 if d[i]>d[i-1]:L+=d[x:i][::-1];x=i
print L

Testuj na repl.it!

Dane wejściowe należy podać jako literał listy w języku Python, na przykład [5, 3, 4, 2, 6, 1].

Podstawową ideą jest częste wykorzystanie składni krojenia Pythona, wycinanie każdej potrzebnej sekcji z tablicy, odwracanie jej i dodawanie do nowej tablicy.

Pyke, 11 8 bajtów ( stara wersja )

$0m<fm_s

Wypróbuj tutaj! (działa na najnowszej wersji)

$        -     delta(input)
 0m<     -    map(i<0 for i in ^)
    f    -   split_at(input, ^)
     m_  -  map(reverse, ^)
       s - sum(^)

Siatkówka , 163 bajty

Tak, wiem jakie to okropne. Wspieranie zer i negatywy było bardzo zabawne. Liczba bajtów zakłada kodowanie ISO 8859-1.

\d+
$*
(?<=-1*)1
x
-

x,1
x¶1
\b(1+),(1+\1)\b
$1¶$2
,,1
,¶1
x,(¶|$)
x¶¶
(?<=\b\1x+(?=,(x+))),\b
¶
O%$#`.(?=(.*))
$.1
+`¶
,
\bx
-x
(\w+)
$.1
^,
0,
,$
,0
,,
,0,
^$
0

Wypróbuj online

Wyjaśnienie:

\d+                         # Convert to unary
$*
(?<=-1*)1                   # Replace negatives with x's instead of 1's
x
-                           # Remove minus sign

x,1                         # Separate if negative before positive
x¶1
\b(1+),(1+\1)\b             # or greater positive follows a positive
$1¶$2
,,1                         # or positive follows a zero
,¶1
x,(¶|$)                     # or zero follows a negative
x¶¶
(?<=\b\1x+(?=,(x+))),\b     # or negative follows a negative of greater magnitude.
¶
O%$#`.(?=(.*))              # Swear at the input, then reverse each line
$.1
+`¶                         # Remove breaks, putting commas back
,
\bx                         # Put the minus signs back
-x
(\w+)                       # Replace unary with length of match (decimal)
$.1
^,                          # Do a bunch of replacements to resurrect lost zeros
0,
,$
,0
,,
,0,
^$
0

05AB1E , 19 18 16 14 bajtów

Zaoszczędzono 2 bajty, używając sztuczki sortowania Luisa Mendo

ü‹X¸ì.pO¹)ø{ø¤

Wypróbuj online!

Wyjaśnienie

Przykładowe dane wejściowe [5, 2, 7, 6, 4, 1, 3]

ü‹               # pair-wise less-than
                 # STACK: [0, 1, 0, 0, 0, 1]
  X¸ì            # prepend a 1
                 # STACK: [1, 0, 1, 0, 0, 0, 1]
     .p          # prefixes
       O         # sum
                 # STACK: [1, 1, 2, 2, 2, 2, 3]
        ¹        # push input
                 # STACK: [1, 1, 2, 2, 2, 2, 3], [5, 2, 7, 6, 4, 1, 3]
         )       # wrap stack in list
                 # STACK: [[1, 1, 2, 2, 2, 2, 3], [5, 2, 7, 6, 4, 1, 3]]
          ø      # zip
                 # STACK: [[1, 5], [1, 2], [2, 7], [2, 6], [2, 4], [2, 1], [3, 3]]
           {     # sort
                 # STACK: [[1, 2], [1, 5], [2, 1], [2, 4], [2, 6], [2, 7], [3, 3]]
            ø    # zip
                 # STACK: [[1, 1, 2, 2, 2, 2, 3], [2, 5, 1, 4, 6, 7, 3]]
             ¤   # tail
                 # OUTPUT: [2, 5, 1, 4, 6, 7, 3]

Poprzednie 16-bajtowe rozwiązanie

Dü‹X¸ì.pO.¡€g£í˜

JavaScript (ECMA 6), 121 128 125 119 108 bajtów

f=a=>{p=a[0],c=[],b=[];for(e of a){e>p&&b.push(c.reverse(c=[]));c.push(p=e)}return[].concat.call([],...b,c)}

Wyrażenie lambda pobiera pojedynczy Arrayparametr a.

Dzięki @ETHproductions za pomoc w zobaczeniu mojego pierwszego błędu.

Rubinowy, 60 55 bajtów

s=->x{x.slice_when{|p,q|p<q}.map{|z|z.reverse}.flatten} 

Prawie o to prosiło wyzwanie. I określonych lambda s, które ma szereg xi Sever (plastry), to na mniejsze kawałki, gdy następny element będzie większy niż. Daje to moduł wyliczający, który możemy nazywać mapą i odwracać kolejność elementów, zanim ostatecznie zbierzemy wszystko razem z spłaszczeniem, które łączy elementy w określonej kolejności w jedną tablicę.

Testy

p s[[1]]===[1]
p s[[1, 1]]===[1, 1]
p s[[1, 2]]===[1, 2]
p s[[2, 1]]===[1, 2]
p s[[2, 3, 1]]===[2, 1, 3]
p s[[2, 1, 3]]===[1, 2, 3]
p s[[2, 1, 2]]===[1, 2, 2]
p s[[2, 1, 1]]===[1, 1, 2]
p s[[3, 1, 1, 2]]===[1, 1, 3, 2]
p s[[3, 2, 1, 2]]===[1, 2, 3, 2]
p s[[3, 1, 2, 2]]===[1, 3, 2, 2]
p s[[1, 3, 2, 2]]===[1, 2, 2, 3]
p s[[1, 0, 5, -234]]===[0, 1, -234, 5]
p s[[1, 0, 1, 0, 1]]===[0, 1, 0, 1, 1]
p s[[1, 2, 3, 4, 5]]===[1, 2, 3, 4, 5]
p s[[5, 4, 3, 2, 1]]===[1, 2, 3, 4, 5]
p s[[2, 1, 5, 4, 3]]===[1, 2, 3, 4, 5]
p s[[2, 3, 1, 5, 4]]===[2, 1, 3, 4, 5]
p s[[5, 1, 4, 2, 3]]===[1, 5, 2, 4, 3]
p s[[5, 2, 7, 6, 4, 1, 3]]===[2, 5, 1, 4, 6, 7, 3]
p s[[-5, -2, -7, -6, -4, -1, -3]]===[-5, -7, -2, -6, -4, -3, -1]
p s[[14, 5, 3, 8, 15, 7, 4, 19, 12, 0, 2, 18, 6, 11, 13, 1, 17, 16, 10, 9]]===[3, 5, 14, 8, 4, 7, 15, 0, 12, 19, 2, 6, 18, 11, 1, 13, 9, 10, 16, 17]

Brachylog , 10 bajtów

~c:{>=r}ac

Wypróbuj online!

Wyjaśnienie

~c            Deconcatenate the Input
  :{>=r}a     Each resulting sublist must be non-increasing, and then reverse it
         c    Concatenate

Dyalog APL , 7 15 bajtów

Wymaga ⎕ML←3, co jest domyślne w wielu systemach. *

{∊⌽¨⍵⊂⍨1+⍵-⌊/⍵}

∊ zaciągnąć się (spłaszczyć)

⌽¨ każdy odwrócony

⍵⊂⍨ argument podzielony na partycje * poprzez wycięcie, gdzie każdy odpowiadający element jest większy niż jego poprzednik

1+ jeden plus

⍵- argument minus

⌊/⍵ najmniejszy element argumentu

Stare 7-bajtowe rozwiązanie kończy się niepowodzeniem z nieujemnymi liczbami całkowitymi:

Wymaga ⎕ML←3, co jest domyślne w wielu systemach. *

∊⌽¨⊆⍨⎕

∊ zaciągnij (spłaszcz)

⌽¨ każdy odwrócony

⊂⍨ dzielony na części *

* Partition ( ⊂) jest funkcją, która odcina swój prawy argument, gdy odpowiadający mu lewy argument jest większy niż poprzedni. (Niestety akceptuje tylko nieujemne liczby całkowite, a zero ma specjalne znaczenie.) Od wersji 16 ta funkcja ⊂jest dostępna we wszystkich systemach (nawet tych, gdzie ⎕ML≠3), za pomocą glifu ⊆.

Haskell, 49 bajtów

(a:b)%l|any(<a)l=l++b%[a]|1<2=b%(a:l)
_%l=l
(%[])

Przykład użycia: (%[]) [5,2,7,6,4,1,3]-> [2,5,1,4,6,7,3].

Podejście rekurencyjne. Funkcja %przyjmuje listę wejść jako swój pierwszy parametr i akumulator, lktóry śledzi dotychczas nie rosnącą porcję (w odwrotnej kolejności). Przypadek podstawowy jest osiągany, gdy lista wejść jest pusta, a wynikiem jest akumulator. Jeśli lista wejściowa nie jest pusta, a pierwszy element anie mieści się w bieżącej porcji ( any(<a)l), zwróć akumulator i dołącz rekurencyjne wywołanie do reszty listy oraz ajako nowego akumulatora ( l++b%[a]). W przeciwnym razie wykonaj rekurencyjne wywołanie na pozostałej części listy i adołącz do tha accumulator ( b%(a:l)). Główna funkcja (%[])wywołuje %z pustym akumulatorem.

Siatkówka , 98 bajtów

Liczba bajtów zakłada kodowanie ISO 8859-1.

$

-(\d+)
$1$*-/
\d+
$*
S-`(?<=(-+)/ )(?!\1)|(?=\b(1+))(?<!\2 )
O%`\S* 
¶

((-)|1)*/? 
$2$#1 
 $

Wypróbuj online!

R, 64 bajty

cat(unlist(lapply(split(x<-scan(),cumsum(c(F,diff(x)>0))),rev)))

Odczytuje dane wejściowe ze standardowego wejścia. Podzieliliśmy dane wejściowe na listę wektorów, split()która wymaga zmiennej czynnikowej grupującej dane wejściowe. Współczynnik jest tworzony przez przyjęcie skumulowanej sumy wektora logicznego, dla którego różnica jest dodatnia.

Rozważ wektor:

x=c(5, 2, 7, 6, 4, 1, 3)

Teraz wzięcie różnicy i kontynuowanie Fprzez uruchomienie y=c(F,diff(x)>0)wygenerowałoby następujący logiczny wektor:

[1] FALSE FALSE  TRUE FALSE FALSE FALSE  TRUE

Biorąc sumę skumulowaną, cumsum(y)powstaje wektor, w którym każda grupa jest reprezentowana przez unikalny czynnik, na podstawie którego możemy łączyć się z splitfunkcją:

[1] 0 0 1 1 1 1 2

Oktawa, 75 44 bajtów

Na podstawie odpowiedzi MATL @LuisMendo

@(a)sortrows([cumsum([1;diff(a)>0]),a])(:,2)

Wypróbuj online!

Poprzednia odpowiedź

@(a)[fliplr(mat2cell(f=fliplr(a),1,diff(find([1,diff(f)<0,numel(a)])))){:}]

Wypróbuj online!

odwróć tablicę

f=fliplr(a)

weź pierwszą różnicę f

d = diff(f);

znajdź pozycję, w której następny element jest mniejszy niż poprzedni element

p=find([1,diff(f)<0,numel(a)])

pierwsza różnica pozycji zwraca długość każdej podtablicy

len=diff(p)

użyj długości każdej podtablicy, mat2cellaby podzielić tablicę na zagnieżdżoną listę tablic

nest = mat2cell(f,1,len);

odwróć listę zagnieżdżoną

rev_nest = fliplr(nest) 

spłaszcz listę zagnieżdżoną

[rev_nest{:}]

Pyth - 15 bajtów

s_McQf<@QtT@QTU

Wypróbuj online tutaj .

Perl 6 , 59 bajtów

{map |+«*.[0].reverse,m/:s([(\-?\d+)<?{[>=] $0}>] +)+/[0]}

Rozwiązanie oparte na regeksie.
Ponieważ to jest Sparta Perl !!

• m/ /: Zmodyfikuj tablicę wejściową i dopasuj do niej wyrażenie regularne.
• (\-? \d+): Dopasuj liczbę i przechwyć jako $0.
• <?{ [>=] $0 }>: Asercja o zerowej szerokości, która pasuje tylko wtedy, gdy wszystkie $0wychwycone do tej pory w bieżącym podpasowaniu są w kolejności rosnącej.
• ([ ] +)+: Powtarzaj dwa ostatnie kroki tak często, jak to możliwe, w przeciwnym razie rozpocznij nowy mecz podrzędny.
• map , [0]: Powtarzaj pod-mecze.
• |+«*.[0].reverse: Dla każdego z nich weź listę dopasowanych wartości $0, odwróć ją, wymuś wartości na liczby ( +«) i wsuń je na zewnętrzną listę ( |).

Perl 6 , 63 bajtów

sub f(\a){flat $_,f a[+$_..*]with first {[<=] $_},:end,[\R,] a}

Rozwiązanie do przetwarzania listy rekurencyjnej.
Bardziej pracochłonny, niż się spodziewałem.
Mimo że język ma wiele wygodnych wbudowanych funkcji, wydaje się, że nie ma żadnego partycjonowania list (np. Ruby slice_whenlub Haskell takeWhile).

Skumulowane , niekonkurencyjne, 34 bajty

Ciągle rozwijam ten język.

{e.b:e b last<}chunkby$revmap flat

Argument dotyczy TOS. Wypróbuj tutaj!

chunkbyprzejmuje funkcję i zbiera tablice ciągłych danych, które spełniają tę funkcję. Funkcja to:

{e.b:e b last<}
{e.b:         }  function with arguments [e, <unused>, b]--the element, <the index>, and the
                 chunk being built
     e       <   check if e is less than
       b last    the last element of b

Daje to ściśle malejącą tablicę.

$revmapjest w zasadzie [rev]mapi odwraca każdy element.

flat w końcu spłaszcza tablicę.

Trochę zabawy podczas sortowania tablicy:

[{e.b:e b last<}chunkby$revmap flat] @:sortstep
[$sortstep periodloop] @:sort

10:> @arr
arr out
arr shuf @arr
arr out
arr sort out

Dane wyjściowe (na przykład):

(0 1 2 3 4 5 6 7 8 9)
(4 5 1 0 6 7 2 8 9 3)
(0 1 2 3 4 5 6 7 8 9)

Python, 151 139 bajtów

Zapisano 12 bajtów dzięki @ Flp.Tkc!

Nigdzie w pobliżu @ Flp.Tkc, a co dopiero ...

def s(l):
 r=[];i=j=0
 while j<len(l)-1:
  if l[j+1]>l[j]:r+=l[i:j+1][::-1],;i=j+1
  j+=1
 r+=l[i:j+1][::-1],;return[i for s in r for i in s]

Python 2, 74 bajty

b=[];c=[];a+=9e9,
for i in a[:-1]:
 b=[a.pop(0)]+b
 if b[0]<a[0]:c+=b;b=[]

Wejście a, wyjściec

Python 3, 191 bajtów

a=[int(i)for i in input().split()]
while a!=sorted(a):
 b=[[]]
 for i,j in enumerate(a):
  if a[i-1]<j:b+=[[j]]
  else:b[-1]+=[j]
 a=[]
 for l in[k[::-1]for k in b]:a+=[k for k in l]
print(a)

Nie jestem pewien, czy używanie sortedfunkcji sprawdzania jest tutaj dozwolone, ale nie mogłem wymyślić żadnego dobrego powodu, aby obniżyć moją liczbę bajtów o ~ 30 bajtów.

Clojure, 105 bajtów

#(filter number?(mapcat reverse(partition-by not(mapcat(fn[[a b]][a(< b a)])(partition 2 1(conj % 1))))))

Partycji w parach o kolejnych numerach, wkłada truelub falsemiędzy nimi, partycje notdo truei numery stać falsei false trueodwraca partycje i zachowuje wartości liczbowych.