Ми називаємо групу парен відкритим пареном (, його відповідним близьким батьком )і всім всередині них.

Група паренів або рядок називається врівноваженою по дужках, якщо вона містить або нічого, або лише 2 групи, врівноважені круглим дужкою.

Наприклад:

The string   "(()())()"      is parenthesly balanced
              (    )()       Because it contains exactly 2 parenthesly balanced parens groups
               ()()          The left one is parenthesly balanced because it contains 2 parenthesly balanced parens groups (balanced because they are empty). The right one is parenthesly balanced because it contains nothing.

Аналогічно:

The string   "(()(()))()"    is not parenthesly balanced
              (      )()     Because it contains a parens group that is not parenthesly balanced: the left one
               ()(  )        The left one is not balanced because it contains a parens group that is not balanced: the right one
                  ()         The right one is not balanced because it only contains one balanced group.

Отже, врівноважена в строках група або parenns повинна:

• Нічого не містять взагалі.
• Або містити лише та точно 2 батьківсько збалансованих групи парен. Він не повинен містити нічого іншого.

Завдання:

Ваше завдання полягає в тому, щоб написати функцію або програму, яка перевіряє, чи заданий рядок є врівноваженим по дузі, чи ні.

Вхід:

Введенням буде рядок або список символів або щось подібне. Ви можете припустити, що рядок буде складатися лише з символів '('і ')'. Можна також припустити , що кожна відкрита дужка (матиме свою відповідну близьку дужку ), так що не турбуйтеся про рядках , як "((("або ")("або "(())("...

^{Примітка: Як згадано @DigitalTrauma в своєму зауваженні сильфона, це нормально subtitute з ()комбо іншими символами (наприклад <>, []...), якщо це викликає додаткову роботу , як уникнути в деяких мовах}

Вихід:

Все, що сигналізує про те, чи є струна врівноваженою чи ні (істина чи помилка, 1 або 0, ...). Будь ласка, включіть у свою відповідь, яку очікується функція / програма.

Приклади:

""                                        => True
"()()"                                    => True
"()(()())"                                => True
"(()(()(()())))(()())"                    => True
"(((((((()())())())())())())())()"        => True
"()"                                      => False
"()()()"                                  => False
"(())()"                                  => False
"()(()(())())"                            => False
"(()())(((((()())()))())())"              => False
"()(()()()())"                            => False
"()(()(()())()())"                        => False

^{Останні два приклади справді змінили значення!}

Удачі!

Japt v2, 20 байт

V="()"V¥iU1 eViV²1 V

Перевірте це в Інтернеті!

Усі спочатку неправильно зрозуміли виклик, і хоча кожна пара дужок повинна містити парне число підпарів, коли насправді виклик насправді вимагає 0 або 2 підпари. Тож ось моя переглянута відповідь, використовуючи ту саму техніку, що і раніше.

Ми все ще можемо вирішити проблему за допомогою рекурсивної заміни. Річ у тому, що замість того, щоб просто видаляти всі події ()(), нам потрібно переконатися, що крім цієї ж обгортки немає нічого іншого ()()(іншими словами, ()()()()нічого подібного). Ми можемо зробити це шляхом рекурсивної заміни (()())на ().

Нова проблема полягає в тому, що вхід сам по собі не має однієї пари зовнішніх дужок (оскільки це зробило б це не врівноваженою дужкою рядка), змусивши нас перетворити його в додаткову пару, щоб повністю зменшити його. Нарешті, кінцевий результат для врівноважених рядків тепер ()замість порожнього рядка, тому ми перевіряємо рівність, а не просто брати логічний НЕ вихід.

sed 4.2.2, 30

:
s/(()())/()/
t
/^()()$\|^$/q1

Спробуйте в Інтернеті .

Це повертає код виходу оболонки 1 для True та 0 для False.

:               # label
s/(()())/()/    # replace "(()())" with "()"
t               # jump back to label if above replacement matched
/^()()$\|^$/q1  # exit code 1 if remaining buffer is exactly "()()" or empty
                # otherwise exit with code 0

Perl 5- lp, 24 22 байти

$_=/^((<(?1)?>){2})?$/

Спробуйте в Інтернеті! Посилання включає тестові випадки. Редагувати: збережено 2 байти завдяки @JoKing. Пояснення: Просто рекурсивний регулярний вираз. Зовнішня група захоплення являє собою врівноважену рядок з <наступною необов'язковою врівноваженою рядком, а потім >два рази. Зауважте, що більшість інших відповідей вміє використовувати ()s, але це коштує додатково два байти:

$_=/^((\((?1)?\)){2})?$/

Спробуйте в Інтернеті! Посилання включає тестові випадки.

Рутинна машина-код 6502 , 48 байт

A0 00 84 FD A2 00 B1 FB F0 0E C8 C9 29 18 F0 06 8A 48 E6 FD 90 EE B0 0A E0 01
90 06 E0 02 38 D0 01 18 A5 FD F0 09 C6 FD 68 AA E8 B0 F5 90 D7 60

Очікує вказівник на рядок в $fb/, $fcякий, як очікується, містить лише (і ). Очищає прапор C (Carry), якщо рядок "парантезовано врівноважений", встановлює його інакше (що є типовою ідіомою для 6502, встановити "на помилку"). Недійсний вхід не робить.

Хоча алгоритм є рекурсивним, він не викликає себе (що потребує більше байтів і робить положення коду залежним), а натомість підтримує глибину рекурсії і використовує "просте" розгалуження.

Прокоментували розбирання

; function to determine a string is "paranthesly balanced"
;
; input:
;   $fb/$fc: address of the string
; output:
;   C flag set if not balanced
; clobbers:
;   $fd:     recursion depth
;   A,X,Y

 .isparbal:
A0 00       LDY #$00            ; string index
84 FD       STY $FD             ; and recursion depth
 .isparbal_r:
A2 00       LDX #$00            ; set counter for parantheses pairs
 .next:
B1 FB       LDA ($FB),Y         ; load next character
F0 0E       BEQ .done           ; end of string -> to final checks
C8          INY                 ; increment string index
C9 29       CMP #$29            ; compare with ')'
18          CLC                 ; and reset carry
F0 06       BEQ .cont           ; if ')' do checks and unwind stack
8A          TXA                 ; save counter ...
48          PHA                 ; ... on stack
E6 FD       INC $FD             ; increment recursion depth
90 EE       BCC .isparbal_r     ; and recurse
 .cont:
B0 0A       BCS .unwind         ; on previous error, unwind directly
 .done:
E0 01       CPX #$01            ; less than one parantheses pair
90 06       BCC .unwind         ; -> ok and unwind
E0 02       CPX #$02            ; test for 2 parantheses pairs
38          SEC                 ; set error flag
D0 01       BNE .unwind         ; if not 2 -> is error and unwind
18          CLC                 ; clear error flag
 .unwind:
A5 FD       LDA $FD             ; check recursion depth
F0 09       BEQ .exit           ; 0 -> we're done
C6 FD       DEC $FD             ; otherwise decrement
68          PLA                 ; get "pair counter" ...
AA          TAX                 ; ... from stack
E8          INX                 ; and increment
B0 F5       BCS .unwind         ; continue unwinding on error
90 D7       BCC .next           ; otherwise continue reading string
 .exit:
60          RTS

Приклад програми асемблера C64 за допомогою підпрограми:

Демонстрація в Інтернеті

Код у синтаксисі ca65 :

.import isparbal   ; link with routine above

.segment "BHDR" ; BASIC header
                .word   $0801           ; load address
                .word   $080b           ; pointer next BASIC line
                .word   2018            ; line number
                .byte   $9e             ; BASIC token "SYS"
                .byte   "2061",$0,$0,$0 ; 2061 ($080d) and terminating 0 bytes

.bss
linebuf:        .res    256

.data
prompt:         .byte   "> ", $0
truestr:        .byte   "true", $0
falsestr:       .byte   "false", $0

.code
inputloop:
                lda     #<prompt        ; display prompt
                ldy     #>prompt
                jsr     $ab1e

                lda     #<linebuf       ; read string into buffer
                ldy     #>linebuf
                ldx     #0              ; effectively 256
                jsr     readline

                lda     #<linebuf       ; address of string to $fb/fc
                sta     $fb
                lda     #>linebuf
                sta     $fc
                jsr     isparbal        ; call function

                bcs     isfalse
                lda     #<truestr
                ldy     #>truestr
                bne     printresult
isfalse:        lda     #<falsestr
                ldy     #>falsestr
printresult:    jmp     $ab1e           ; output true/false and exit

; read a line of input from keyboard, terminate it with 0
; expects pointer to input buffer in A/Y, buffer length in X
.proc readline
                dex
                stx     $fb
                sta     $fc
                sty     $fd
                ldy     #$0
                sty     $cc             ; enable cursor blinking
                sty     $fe             ; temporary for loop variable
getkey:         jsr     $f142           ; get character from keyboard
                beq     getkey
                sta     $2              ; save to temporary
                and     #$7f
                cmp     #$20            ; check for control character
                bcs     checkout        ; no -> check buffer size
                cmp     #$d             ; was it enter/return?
                beq     prepout         ; -> normal flow
                cmp     #$14            ; was it backspace/delete?
                bne     getkey          ; if not, get next char
                lda     $fe             ; check current index
                beq     getkey          ; zero -> backspace not possible
                bne     prepout         ; skip checking buffer size for bs
checkout:       lda     $fe             ; buffer index
                cmp     $fb             ; check against buffer size
                beq     getkey          ; if it would overflow, loop again
prepout:        sei                     ; no interrupts
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and clear 
                and     #$7f            ;   cursor in
                sta     ($d1),y         ;   current row
output:         lda     $2              ; load character
                jsr     $e716           ;   and output
                ldx     $cf             ; check cursor phase
                beq     store           ; invisible -> to store
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and show
                ora     #$80            ;   cursor in
                sta     ($d1),y         ;   current row
                lda     $2              ; load character
store:          cli                     ; enable interrupts
                cmp     #$14            ; was it backspace/delete?
                beq     backspace       ; to backspace handling code
                cmp     #$d             ; was it enter/return?
                beq     done            ; then we're done.
                ldy     $fe             ; load buffer index
                sta     ($fc),y         ; store character in buffer
                iny                     ; advance buffer index
                sty     $fe
                bne     getkey          ; not zero -> ok
done:           lda     #$0             ; terminate string in buffer with zero
                ldy     $fe             ; get buffer index
                sta     ($fc),y         ; store terminator in buffer
                sei                     ; no interrupts
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and clear 
                and     #$7f            ;   cursor in
                sta     ($d1),y         ;   current row
                inc     $cc             ; disable cursor blinking
                cli                     ; enable interrupts
                rts                     ; return
backspace:      dec     $fe             ; decrement buffer index
                bcs     getkey          ; and get next key
.endproc

V , 21 , 20 байт

é(Á)òÓ(“()()…)òø^()$

Спробуйте в Інтернеті! або Перевірте всі тестові випадки!

é(                      " Insert '(' at the beginning of the line
  Á)                    " Append ')' at the end
    ò         ò         " Recursively...
     Ó                  "   Remove...
      (                 "     '('
       “    …           "     (Limit the part that is removed to this section of the match)
        ()()            "     '()()'
             )          "     ')'
                        " (effectively, this replaces '(()())' with '()', but it's one byte shorter than the straightforward approach
               ø        " Count...
                ^()$    "   Lines containing exactly '()' and nothing more

Hexdump:

00000000: e928 c129 f2d3 2893 2829 2829 8529 f2f8  .(.)..(.()().)..
00000010: 5e28 2924                                ^()$

Брахілог , 28 байт

Ẹ|~c["(",A,")(",B,")"]∧A;B↰ᵐ

Спробуйте в Інтернеті!

Пояснення

                                    --  The string perfectly balanced iff
Ẹ                                   --      the string is empty
 |                                  --  or
  ~c["(",A,")(",B,")"]              --      the string can be written id the format of "($A)($B)"
                      ∧             --          where
                       A;B ᵐ        --          both A and B
                          ↰         --          are perfectly balanced

C (gcc) , 113 байт

p(a,r,e,n)char*a;{if(*a-40)return 1;for(r=1,e=0;e<2;r&=e++||*a==40)for(r*=n=p(++a);n+=*a++-40?~0:1;);r=r&&*a-40;}

Спробуйте в Інтернеті!

Пояснення

p(a,r,e,n)char*a;{   // function and variable declaration
 if(*a-40)return 1;  // string does not start with '(', thus is empty
 for(r=1,e=0;e<2;    // r: return value, e: group id (look for exactly two groups)
 r&=e++||*a==40)     // after the first group, a second shall follow
  for(r*=n=p(++a);   // check that the group is itself balanced
  n+=*a++-40?~0:1;); // skip group
 r=r&&*a-40;}        // additionally, after those two groups there shall follow none

Спробуйте в Інтернеті!

MATL , 26 25 байт

oo~`tnw52B5LZttnb<]XB10X-

Спробуйте в Інтернеті!

Завдяки відповіді @ETHProductions за ідею "заміна (() ()) на ()", а також питання @JungHwan Min прокоментував ідею бачити дужки як двійкові цифри.

Вихід - це порожній масив для truthy, позитивне число для falsey - що, на мою думку, дозволено коментарем ОП: "Можливо категорії. Якщо це не так, ми можемо додати nв кінці для байта +1, щоб мати 0 як триєдний вихід і 1 як фальсийний вихід.

З коментарями:

o         % Convert the parantheses to their ASCII codes
          %  40 for '(', 41 for ')'
o         % Parity - 1 for odd, 0 for even
~         % Not - change 0 to 1 and vice versa, so '(' is now 1 and ')' 0
          % Input char array is now a binary array B
`         % Do-while loop
  tn          % Get the length of the array 
  w           % Bring the array B back on top
  52B         % Push the binary value of 52 on stack
              %  [1 1 0 1 0 0] (equivalent to '(()())')
  5L          % Push the constant [1 0] for '()'
  Zt          % Replace the sequence [1 1 0 1 0 0] in array B
              %  with [1 0]
  tn          % Get the length of the array after replacement 
  b<          % Has it decreased? If so, continue loop
  ]       % end loop
          % Final value for balanced input will be
          %  either [1 0 1 0] for the remaining outer '()()'
          %  or an empty array [] for empty '' input
XB        % Convert the final binary array back to decimal
10X-      % Set difference, remove 10 from that result 
          % Result is [] empty array for balanced input, otherwise 
          %  some decimal number ≠ 10 for unbalanced input

C # (.NET Core) , 78 71 байт

f=s=>{var r=s.Replace("(()())","()");return r==s?s==""|s=="()()":f(r);}

Спробуйте в Інтернеті!

Haskell , 82 59 байт

all(`elem`[0,2]).foldl(#)[0]
b#'('=0:b
(x:y:z)#_=y+1:z++[x]

Спробуйте в Інтернеті!

Я припускаю, що в гольф можна набагато далі, оскільки це вперше гольф у хаскеллі, тому будь-які трюки чи коментарі більш ніж вітаються.

EDIT - Дякую @nimi за збереження 23 байтів (понад 28% від початкового подання :)

JavaScript (ES6), 63 байти

Вводить дані як масив символів. Повертає помилку для збалансованої батьківської думки, істинну для не врівноваженої батьківської думки.

a=>[...a,k=0].some(c=>c<')'?!(a[k]=-~a[k++]):a[k]=~5>>a[k--]&1)

Спробуйте в Інтернеті!

Прокоментував

a =>                     // a[] = input array of characters; we are going to reuse it to
  [                      // store the number of parenthesis groups at each depth
    ...a,                // append all characters
    k = 0                // initialize k = current depth to 0 and append a value that will
  ]                      // be treated as a final closing parenthesis for the root level
  .some(c =>             // for each character c in this array:
    c < ')' ?            //   if c is an opening parenthesis:
      !(                 //     increment the number of groups at the current depth
        a[k] = -~a[k++]  //     increment the depth
      )                  //     yield false
    :                    //   else:
      a[k] = ~5          //     make sure that the current depth contains either 0 or 2
             >> a[k--]   //     groups, by shifting the 1-complement of 5 (101 in binary)
             & 1         //     and testing the least significant bit
                         //     it resets the number of groups to 0 if the bit is not set
                         //     otherwise, it forces some() to return true
                         //     decrement the depth
  )                      // end of some()

Рекурсивна, 54 байти

Використання рекурсивних замін (наприклад, в Однак відповіді "Eptproductions" ) значно коротше.

Вводиться як рядок. Повертає 1 для вирівнювання батьків, 0 для не збалансованого у батьків.

f=s=>s==(s=s.split`(()())`.join`()`)?!s|s=='()()':f(s)

Спробуйте в Інтернеті!

Рекурсивний, 46 байт

Це видає помилку рекурсії для не врівноважених дужок:

f=s=>!s|s=='()()'||f(s.split`(()())`.join`()`)

Спробуйте в Інтернеті!

Perl 6 ,  43 41  37 байт

{my rule f{\([<&f>**2]?\)};?/^<&f>**2$|^$/}

Перевірте це

{(my$f)=/\([<$f>**2]?\)/;?/^[<$f>**2]?$/}

Перевірте це

{$!=/\([<$!>**2]?\)/;?/^[<$!>**2]?$/}

Перевірте це

Розширено:

{  # bare block lambda with implicit parameter $_

  $! = # store regex into $! (no need to declare it)
  /
    \(

      [
        <$!> ** 2 # recurse into regex twice
      ]?          # optionally

    \)
  /;


  ?      # boolify (causes it to be run against $_)

    /
      ^         # beginning of string

      <$!> ** 2 # match using regex twice

      $         # end of string

    |           # or

      ^ $       # empty string
    /
}

R , 71 байт

f=function(s,r=sub('(()())','()',s,f=T))'if'(r==s,s==''|s=='()()',f(r))

Спробуйте в Інтернеті!

• перенесення рекурсивного Japt розчину @ETHproductions
• -2 байти завдяки @JayCe

Інше - більш тривале рішення, але цікаве для іншого підходу

R , 85 байт

g=gsub;!sum(eval(parse(t=g('\\)\\(',')-(',g('\\)','-1)',g('\\(','(2+',scan(,'')))))))

Спробуйте в Інтернеті!

Пояснення:

Візьміть рядок введення та замініть:

'('  with '(2+'
')'  with '-1)'
')(' with ')-('

потім оцінює отриманий вираз. Якщо він дорівнює нулю, врівноважений, інакше - ні. Використання sumпотрібне лише для обробки випадку порожнього рядка, оскільки його оцінка повертається NULL.

напр

()(()()) => (2+-1)-(2+(2+-1)-(2+-1)-1) = 0
(()())   => (2+(2+-1)-(2+-1)-1)        = 1

Мова Вольфрама (Mathematica) , 65 байт

#=={}||{1,1}==(#//.{a___,"(",i:1...,")",b___}/;1!=+i<3:>{a,1,b})&

Спробуйте в Інтернеті!

05AB1E , 18 16 13 байт

…(ÿ)…(()∞„()©:®Q

Порт відповіді Japt @ETHproductions для виправлення тестового випадку ()(()()(()())(()())).
-2 байти завдяки @Adnan .

На основі цього коментаря до ОП я зараз використовую ()як ціннісну цінність, а все інше як фальси. Якщо обидва значення потрібно узгоджувати замість лише одного, це був би старий 16- байтовий відповідь, а не ( …(ÿ)…(()∞„()©:®Q), повертаючись 0для трити та 1для тестових випадків фальси.

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Пояснення

…(ÿ)             # Take the input (implicitly) and surround it with "(" and ")"
            :    # Infinite replacement of:
    …(()∞        #  "(()())"    ("(()" mirrored)
         „()     #  with "()"
                 # After the infinite replacement: return the result
                 # ("()" for truthy; falsey otherwise)

(Старий 18-байтний відповідь, який не вдався до тестового випадку ()(()()(()())(()()))..):

ΔD„()∞©6∍å_i®õ.:]Ā

Спробуйте в Інтернеті або перевірте всі тестові випадки .

APL (Dyalog Classic) , 27 байт

3>≢'<<><>>'⎕r'<>'⍣≡1⌽'><',⎕

Спробуйте в Інтернеті!

Пролог , 46 байт

a-->p,p.
a-->[].
p-->[l],a,[r].
f(X):-a(X,[]).

Спробуйте в Інтернеті! або Перевірте всі тестові випадки!

Використовує списки lта rяк вхід, наприклад "()()", тестується як f([l,r,l,r])..

Перші три рядки є граматикою дійсних рядків у синтаксисі граматики визначеного пункту Пролога . a(A,B).повертає, trueколи A- це список, який слід за граматикою та Bпорожній. Таким чином, основна функція fзаймає деяку частину Xі перевіряє, чи a(X,[])виконується.

Python 2 , 73 71 байт

f=lambda s,P='(()())':P in s and f(s.replace(P,'()'))or s in['()()','']

Спробуйте в Інтернеті!

мозковий ебать, 50 байт

,[<+>[-[->>]<[-[--[>->,]]>>]<]<[>>],]<[--[>->]]<+.

Відформатовано:

,
[
  <+>
  [
    -[->>]
    <
    [
      -
      [
        --
        [
          >->,
        ]
      ]
      >>
    ]
    <
  ]
  <[>>]
  ,
]
<
[
  --
  [
    >->
  ]
]
<+.

Очікує рядок з ( і )без зворотного нового рядка, і виводить \x01для істинного та \x00для помилкового. (Для розбірливості ви можете, наприклад, додати 48 +с до фіналу, .щоб зробити його друком 1і 0замість цього.)

Спробуйте в Інтернеті

Це підтримує стек з кількістю груп на кожній глибині, розрізняючи символи за паритетом і перевіряючи, чи кількість груп у {0, 2} після кожного закритого дужки; якщо умова не виконується, споживає решту вхідних даних і встановлює прапор; потім ще раз перевіряє стан в кінці програми.

Якщо нам дозволено припинити вхідний потік із непарним символом, ми можемо опустити остаточну перевірку, <[--[>->]]щоб зберегти 10 байт. (Якби \nнавіть не було незручно, я б запропонував цей варіант як основну відповідь.)

(Ми також могли б зберегти деякі байти, змінивши вихідний формат на \x00істинний та не-\x00 на хибний, що, мабуть, дозволено (можливо, випадково) заявою проблеми, як написано, але все одно це було б не дуже цікаво, і я вважаю за краще не вносити цих змін.)

Python2, 95 94 байт

f=lambda i:g(eval("(%s)"%i.replace(")","),")))
g=lambda i:len(i)in(0,2)and all(g(j)for j in i)

Спробуйте в Інтернеті!

f () перетворює рядок у вкладений кортеж, який він передає g ().

g () рекурсивно переміщається по кортежу та повертає False, якщо в будь-якому елементі немає точно 0 або 2 дітей.

Збережено один байт за допомогою рядкового форматування.

Стакс , 13 11 байт

₧aaS▐îî»Å·╢

Запустіть і налагоджуйте його

Я врятував два байти, коли зрозумів, що вхідні дані можуть збігнутись неявно, як літерали масиву. Видаляючи подвійні лапки, введення спрощується.

Загальна ідея полягає в тому, щоб оцінювати введення як літерал масиву та рекурсивно відображати елементи, щоб перевірити рівновагу балансу. Якщо остаточне твердження коли-небудь не вдасться, то на порожній стеці буде поданий наступний перегляд. У stax вискакування з порожніми стеками негайно припиняє програму.

Розпакований, неозорений та коментований, це виглядає приблизно так.

        input is implicitly treated as array literals
L       wrap entire input stack in an array
G       jump to the trailing '}', and come back when done
}       terminate the program, the rest is a recursive call target
{Gm     map array on top of the stack by using the recursive call target
%       get the length of the mapped array
02\#    is the length one of [0, 2]?
|c      assert value is truthy, pop if not

Виконати цей

Java 10, 99 96 95 83 байт

s->{s="("+s+")";for(var p="";!p.equals(s);s=s.replace("(()())","()"))p=s;return s;}

Порт моєї відповіді 05AB1E (так само повертається() як триут і все інше, як фальси).

Спробуйте в Інтернеті.

Пояснення:

s->{                 // Method with String as both parameter and return-type
  s="("+s+")";       //  Surround the input-String between "(" and ")"
  for(var p="";      //  Previous-String, starting empty
      !p.equals(s)   //  Loop as long as the previous and current Strings differ
      ;              //    After every iteration:
       s=s.replace("(()())","()"))
                     //     Replace all "(()())" with "()"
    p=s;             //   Set the previous String with the current
  return s;}         //  Return the modified input-String
                     //  (if it's now "()" it's truthy; falsey otherwise)

return s;може бути, return"()".equals(s);якщо потрібен був фактичний булевий результат.