Ciò è stato ispirato dal Problema 13 - Binario non ripetuto della recente competizione di HP CodeWars.

Prendiamo un numero decimale casuale, diciamo

727429805944311

e guarda la sua rappresentazione binaria:

10100101011001011111110011001011101010110111110111

Ora dividere che la rappresentazione binaria in sottosequenze dove le cifre 0e 1si alternano.

1010 010101 10 0101 1 1 1 1 1 10 01 10 0101 1 1010101 101 1 1 1 101 1 1

E converti ogni sottosequenza in decimale.

10 21 2 5 1 1 1 1 1 2 1 2 5 1 85 5 1 1 1 5 1 1

L'obiettivo

Prendi un singolo numero intero positivo come input e genera la sequenza di numeri interi positivi ottenuti dal processo precedente.

Dettagli

• L'input e l'output devono essere decimali o unari.
• I numeri nell'output devono essere separati in modo sensibile e leggibile dall'uomo e devono essere decimali o unari. Nessuna restrizione sullo spazio bianco. Stili di output validi: [1,2,3], 1 2 3, 1\n2\n3in cui \nsono a capo letterali, ecc

Casi test

 Input | Output
     0 | 0
     1 | 1
     2 | 2
     3 | 1 1
     4 | 2 0
     5 | 5
     6 | 1 2
     7 | 1 1 1
     8 | 2 0 0
     9 | 2 1
    10 | 10
    50 | 1 2 2
   100 | 1 2 2 0
  1000 | 1 1 1 1 10 0 0
 10000 | 2 1 1 2 0 2 0 0 0
 12914 | 1 2 2 1 1 2 2
371017 | 5 42 10 2 1

Nota aggiuntiva: tutti i numeri nell'output devono essere nella forma (2^k-1)/3o 2*(2^k-1)/3. Cioè 0 1 2 5 10 21, 42, 85, 170, ..., che è A000975 nell'OEIS.

Pyth, 17 16 byte

1 byte grazie a Jakube

iR2cJ.BQx1qVJ+dJ

Dimostrazione

Una soluzione simpatica e intelligente. Utilizza alcune funzionalità meno conosciute di Pyth, come x<int><list>e c<str><list>.

iR2cJ.BQx1qVJ+dJ
                    Q = eval(input())
    J.BQ            Store in J the input in binary.
          qV        Vectorize equality function over
            J+dJ    J and J with a leading dummy char, to get the offset right.
                    This calculates whether each element matches its successor.
        x1          Find all of the indexes of 1 (True) in this list.
   cJ                Chop J at those locations.
iR2                  Convert from binary back to base ten and output.

Mathematica, 47 byte

#+##&~Fold~#&/@#~IntegerDigits~2~Split~Unequal&

Ungolfed:

FromDigits[#,2]&/@Split[IntegerDigits[#,2],Unequal]&

Split[list,f]divide un elenco in più elenchi, interrompendo la posizione tra ae biff f[a,b]non ritorna True.

FromDigits[n,2] => Fold[#+##&,n]è un suggerimento accurato di alephalpha.

Python, 86 byte

Da quando sono diventato orribilmente superato in Pyth, facciamolo di nuovo in Python.

import re
lambda n:[int(s,2)for s in re.sub("(?<=(.))(?=\\1)"," ",bin(n)[2:]).split()]

Provalo qui!

Spiegazione

Iniziamo con la conversione del numero di input nin una stringa binaria. bin(n)[2:]se ne occupa. Dobbiamo scartare i primi 2 caratteri di questa stringa poiché bin()restituisce la stringa nel formato 0b10101.
Successivamente è necessario identificare i bordi delle sottosequenze. Questo può essere fatto con la regex (?<=(.))(?=\1)che corrisponde alle posizioni di lunghezza zero nella stringa che hanno lo stesso numero a sinistra e a destra.
Il modo più ovvio per ottenere un elenco di tutte le sottosequenze sarebbe l'uso re.split()che divide una stringa su una certa regex. Sfortunatamente questa funzione non funziona per le partite di lunghezza zero. Ma per fortuna lo re.sub()fa, quindi sostituiamo quelle partite di lunghezza zero con spazi e suddividiamo la stringa su quelle successive.
Quindi non ci resta che analizzare ciascuna di queste sottosequenze in un numero decimale con int(s,2)e il gioco è fatto.

Gelatina, 12 byte

BI¬-ẋż@BFṣ-Ḅ

Provalo online! o verifica tutti i casi di test .

Come funziona

BI¬-ẋż@BFṣ-Ḅ  Main link. Argument: n

B             Convert n to base 2.
 I            Compute the increments, i.e., the differences of consecutive digits.
  ¬           Apply logical NOT.
   -ẋ         Repeat -1 that many times, for the logical NOT of each difference.
              [0, 0] / [1, 1] ->   0    -> 1 -> [-1]
              [0, 1] / [1, 0] -> 1 / -1 -> 0 -> []
       B      Yield n in base 2.
     ż@       Zip the result to the right with the result to the left.
        F     Flatten the resulting list of pairs.
         ṣ-   Split at occurrences of -1.
           Ḅ  Convert each chunk from base 2 to integer.

Utilità Bash + GNU, 51

dc -e2o?p|sed -r ':;s/(.)\1/\1 \1/;t'|dc -e2i?f|tac

Input prelevato da STDIN.

• dc -e2o?p legge l'input intero da STDIN e genera una stringa di base 2
• sed -r ':;s/(.)\1/\1 \1/;t' divide la stringa di base 2 con uno spazio ovunque ci siano le stesse cifre consecutive
• dc -e2i?flegge il binario diviso in una volta sola, mettendo ciascuna parte nello stack, quindi fscarica l'intero dcstack (numeri di output in ordine inverso) ...
• ... che è corretto da tac.

JavaScript (ES6) 58 62 63

Modifica 1 byte salvato grazie a @ETHproductions

Modifica 4 byte salvati grazie a @Neil

x=>x.toString(2).replace(/((.)(?!\2))*./g,x=>'0b'+x-0+' ')

f=x=>x.toString(2).replace(/((.)(?!\2))*./g,x=>'0b'+x-0+' ')

 
console.log=x=>O.textContent+=x+'\n'

;[
[     0,'0'],
[     1,'1'],
[     2,'2'],
[     3,'1 1'],
[     4,'2 0'],
[     5,'5'],
[     6,'1 2'],
[     7,'1 1 1'],
[     8,'2 0 0'],
[     9,'2 1'],
[    10,'10'],
[    50,'1 2 2'],
[   100,'1 2 2 0'],
[  1000,'1 1 1 1 10 0 0'],
[ 10000,'2 1 1 2 0 2 0 0 0'],
[ 12914,'1 2 2 1 1 2 2'],
[371017,'5 42 10 2 1']
].forEach(t=>{
  var i=t[0],k=t[1],r=f(i)
  console.log(i+' -> '+r+(r.trim()==k.trim() ? ' ok':'ko (should be '+k+')'))
})

<pre id=O></pre>

Pyth, 26 byte

iR2c:.BQ"(?<=(.))(?=\\1)"d

Provalo qui!

Spiegazione

iR2c: .BQ "(? <= (.)) (? = \\ 1)" d # Q = numero di input

     .BQ # Converte l'input in binario
    : "(? <= (.)) (? = \\ 1)" d # inserisce uno spazio bianco tra le sottosezioni
   c # dividere la stringa su spazi bianchi
iR2 # converte ogni sottosequenza in decimale

Poiché la funzione split () di Python non si divide su corrispondenze di lunghezza zero, devo sostituire quelle corrispondenze con uno spazio e dividere il risultato su quello.

Pyth, 22 21 byte

&Qu?q%G2H&
GH+yGHjQ2Z

Provalo online: dimostrazione

Davvero un compito noioso in Pyth.

Spiegazione:

&Qu?q%G2H&\nGH+yGHjQ2Z   implicit: Q = input number
                  jQ2    convert Q to base 2
  u               jQ2Z   reduce ^: for each digit H update the variable G=0:
   ?q%G2H                   if G%2 == H:
          \nG                  print G
         &   H                 then update G with H
              +yGH           else: update G with 2*G+H
  u                      print the last G also
&Q                       handle Q=0 special: only print 0 once

05AB1E , 18 byte

Codice:

b2FNð«N«Dð-s:}ð¡)C

Spiegazione:

b                   # Convert input to binary
 2F          }      # Do the following twice ( with N as range variable)
   Nð«N«            #    N + space + N
        D           #    Duplicate this
         ð-         #    Delete spaces from the duplicate string
           s        #    Swap the top two elements
            :       #    Replace the first string with the second
              ð¡    # Split on spaces
                )   # Wrap into an array
                 C  # Convert all element back to decimal

Provalo online!

Utilizza la codifica CP-1252 .

MATL , 18 17 byte

YBTyd~Thhfd1wY{ZB

Provalo online!

YB      % input number. Convert to binary string
T       % push true value
y       % duplicate binary string and push it at the top of the stack
d~      % true for each value that equals the previous one
T       % push true value
hh      % concatenate: true, indices, true
f       % find indices of true values
d       % consecutive differences: lenghts of alternating sequences
1wY{    % split binary string according to those lengths
ZB      % convert each substring into decimal number

zsh, 67 63 55 byte

for i in `grep -oP '1?(01)*0?'<<<$[[##2]$1]`;<<<$[2#$i]

Non so perché, ma questo non funziona in Bash.

Grazie a Dennis per 8 byte!

PHP, 171 168 162 160 158 121 120 131 124 118 116 113 112 byte

function d($i){for(;$d<$l=strlen($b=decbin($i));){$c.=$u=$b[$d];echo$u==$b[++$d]||$d==$l?bindec($c).$c=" ":"";}}

function d($i) {
  for ( ; $d < $l = strlen($b = decbin($i)); ) {
    $c .= $u = $b[$d];
    echo $u == $b[++$d] || $d == $l ? bindec($c) . $c = " "
                                    : "";
  }
}

Usa d(int)e sei spento, l'output è una echostringa di ints separata da uno spazio.

modifiche:
-3:$b definizione spostata in strlen()chiamata.
-6:$c istanza rimossa .
-2: risolto finalmente il problema di concatenazione.
-2: nessuna parentesi per riga singola for().
-37: revisione totale. Andare con Arraychunklet invece di ripetute Array-> String-> Arraychiamate.
-1:$c ripristino subdolo .
+11: Bugfix. Mancava il pezzo finale. Non piu.
-7: Non è necessario istanziare $daffatto? Bello.
-6: return -> echo.
-2: scricchiolio $c.
-3:Ternary, il mio primo amore.
-1: subdolo subdolo $u.

Convesso 0,2+, 25 byte

Convex è un nuovo linguaggio che sto sviluppando che è fortemente basato su CJam e Golfscript. L'interprete e l'IDE sono disponibili qui . L'input è un numero intero negli argomenti della riga di comando. Questo utilizza la codifica CP-1252 .

2bs®(?<=(.))(?=\\1)"ö2fbp

Spiegazione:

2bs                         Convert to binary string
   ®(?<=(.))(?=\\1)"        Regex literal
                    ö       Split string on regex
                     2fb    Convert each split string into decimal integer
                        p   Print resulting array

Java 8, 127 119 byte

l->new java.util.ArrayList<Long>(){{for(String s:l.toBinaryString(l).split("(?<=(.))(?=\\1)"))add(l.parseLong(s,2));}};

C'è probabilmente una migliore espressione regolare là fuori per dividere la stringa. Non sono esperto di regex, ma continuerò a sperimentare.

-8 byte grazie a @FryAmTheEggman

APL (APL) , 21 25 byte

Ora gestisce anche 0.

{0::0⋄2⊥¨⍵⊂⍨1,2=/⍵}2⊥⍣¯1⊢

Provalo online!

2⊥⍣¯1⊢ converti in base-2, usando tutti i bit necessari (conversione inversa da-base-2)

{... } applica la seguente funzione anonima

0:: se si verifica un errore:

  0 ritorna 0

 ⋄ ora prova:

  2=/⍵ uguaglianza a coppie dell'argomento (fallirà una rappresentazione binaria lunghezza-0 di uno 0)

  1, anteporre 1

  ⍵⊂⍨ usalo per partizionare l'argomento (inizia una nuova sezione su ogni 1)

  2⊥¨ converti ciascuno da base-2

Japt , 7 byte

¤ò¥ mn2

Provalo

Spiegazione

¤ò¥ mn2
           :Implicit input of integer U.
¤          :Convert to binary string.
 ò¥        :Split to an array by checking for equality.
    m      :Map over array.
     n2    :Convert to base-10 integer.

Python 3, 115 byte

def f(s):
 s=bin(s);r=[s[2]]
 for i in s[3:]:
  if i==r[-1][-1]:r+=[i]
  else:r[-1]+=i
 return[int(x,2)for x in r]

Spiegazione

def f(s):
 s=bin(s)                   # convert input in binary
 r=[s[2]]                   # initialize the result with the first char after the 'b' in binary string
 for i in s[3:]:            # loop on other element
  if i==r[-1][-1]:          # if the last element of the last string equal the current element 
   r+=[i]                   # we add the current element in a new string
  else:
   r[-1]+=i                 # we add the current element to the last sting
 return[int(x,2)for x in r] # convert binary string in integer 

risultati

>>> [print(i,f(i)) for i in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 50, 100, 1000, 10000, 12914, 371017]]
0 [0]
1 [1]
2 [2]
3 [1, 1]
4 [2, 0]
5 [5]
6 [1, 2]
7 [1, 1, 1]
8 [2, 0, 0]
9 [2, 1]
10 [10]
50 [1, 2, 2]
100 [1, 2, 2, 0]
1000 [1, 1, 1, 1, 10, 0, 0]
10000 [2, 1, 1, 2, 0, 2, 0, 0, 0]
12914 [1, 2, 2, 1, 1, 2, 2]
371017 [5, 42, 10, 2, 1]

soluzione precedente (118 byte)

def f(s):
 s=bin(s);r=s[2]
 for i in s[3:]:
  if i==r[-1]:r+='a'+i
  else:r+=i
 return[int(x,2)for x in r.split('a')]

Haskell, 147 , 145 byte

x%[]=[x]
x%(y:z)|or.(zipWith(==)<*>tail)$y:x=x:[]%(y:z)|1<2=(y:x)%z
b x|x<2=[x]|1<2=b(div x 2)++[mod x 2]
map(sum.zipWith((*).(2^))[0..]).([]%).b

map(sum.zipWith((*).(2^))[0..]).([]%).b è una funzione senza nome che calcola l'elenco.

Meno golf:

alternating :: Eq a => [a] -> Bool
alternating = or . (zipWith (==) <*> tail)

-- (%) is the partitioning function
(%) :: Eq a => [a] -> [a] -> [[a]]
x % [] = [x]

x % (y:z) | alternating (y : x) = x : [] % (y:z)
          | otherwise = (y : x) % z

bits :: Integral t => t -> [t]
bits x | x < 2     = [x] 
       | otherwise = bits (div x 2) ++ [mod x 2]

unBits :: Num c => [c] -> c
unBits = sum . zipWith ((*) . (2^)) [0..]

f :: Integer -> [Integer]
f = map unBits . ([]%) . bits

Perl, 53 byte

Include +1 per -p

Esegui con il numero su STDIN

perl -p alterbits.pl <<< 371017

alterbits.pl:

$_=sprintf"0b%b",$_;s/(.)\K(?=\1)/ 0b/g;s/\S+/$&/eeg

PowerShell, 103 byte

[regex]::Matches([convert]::ToString($args[0],2),"(01)+0?|(10)+1?|.").Value|%{[convert]::toint32($_,2)}

Dato che sono orribile in regex, sto usando la stessa espressione della risposta di edc65 .

Assolutamente distrutto dalle lunghe chiamate .NET per eseguire la conversione da / in binario e dalla chiamata .NET per ottenere le corrispondenze regex. Altrimenti piuttosto semplice. Prende l'input $args[0], convertlo fa in binario, lo immette Matches, prende gli .Values risultanti , li convoglia attraverso un loop |%{...}econvert riporta a quei valori int. L'output viene lasciato sulla pipeline e implicitamente stampato con nuove righe.

Per credito extra - una versione (principalmente) non regex a 126 byte

$l,$r=[char[]][convert]::ToString($args[0],2);$l+-join($r|%{(" $_",$_)[$l-bxor$_];$l=$_})-split' '|%{[convert]::toint32($_,2)}

Prendiamo di nuovo l'input $args[0]e convertlo facciamo in binario. Riconfiguriamo come char-array, memorizzando il primo personaggio $le i rimanenti $r. Inviamo quindi $rattraverso un ciclo in |%{...}cui ogni iterazione che selezioniamo dal carattere anteposto con uno spazio o solo dal carattere, a seconda del risultato di un xor binario con $l, e quindi impostato$l uguale al carattere. Ciò garantisce in modo efficace che se abbiamo lo stesso personaggio due volte di seguito, anteponiamo uno spazio tra di loro.

L'output del loop viene -joineditato insieme e aggiunto al primo carattere $l, quindi -splitagli spazi (che è tecnicamente una regex, ma non ho intenzione di contarlo). Facciamo quindi lo stesso loop della risposta regex a converte restituiamo numeri interi.

Java 345 byte

package com.ji.golf;
import java.util.regex.*;
public class Decompose {
  public static String decompose(long l) {
    String o="";
    String s=Long.toBinaryString(l);
    Matcher m=Pattern.compile("(01)+(0)?|(10)+(1)?|(1)|(0)").matcher(s);
    while(m.find()){String c=s.substring(m.start(),m.end());o+=Integer.parseInt(c, 2)+" ";}
    return o;
  }
}

Test

package com.ji.golf;
public class DecompseTest {
  public static void main(String[] args) {
    String[] inOut = new String[]{
        "0,0",
        "1,1",
        "2,2",
        "3,1 1",
        "4,2 0",
        "5,5",
        "6,1 2",
        "7,1 1 1",
        "8,2 0 0",
        "9,2 1",
        "10,10",
        "50,1 2 2",
        "100,1 2 2 0",
        "1000,1 1 1 1 10 0 0",
        "10000,2 1 1 2 0 2 0 0 0",
        "12914,1 2 2 1 1 2 2",
        "371017,5 42 10 2 1"
    };
    for (String s : inOut) {
      String[] io = s.split(",");
      String result = Decompose.decompose(Long.parseLong(io[0]));
      System.out.println("in: " + io[0] + ", reusult: [" +  result.trim() + "], validates? " + result.trim().equals(io[1].trim()));
    }
  }
}

Produzione

in: 0, reusult: [0], validates? true
in: 1, reusult: [1], validates? true
in: 2, reusult: [2], validates? true
in: 3, reusult: [1 1], validates? true
in: 4, reusult: [2 0], validates? true
in: 5, reusult: [5], validates? true
in: 6, reusult: [1 2], validates? true
in: 7, reusult: [1 1 1], validates? true
in: 8, reusult: [2 0 0], validates? true
in: 9, reusult: [2 1], validates? true
in: 10, reusult: [10], validates? true
in: 50, reusult: [1 2 2], validates? true
in: 100, reusult: [1 2 2 0], validates? true
in: 1000, reusult: [1 1 1 1 10 0 0], validates? true
in: 10000, reusult: [2 1 1 2 0 2 0 0 0], validates? true
in: 12914, reusult: [1 2 2 1 1 2 2], validates? true
in: 371017, reusult: [5 42 10 2 1], validates? true

Julia, 70 57 byte

n->map(i->parse(Int,i,2),split(bin(n),r"(?<=(.))(?=\1)"))

Questa è una funzione anonima che accetta un numero intero e restituisce un array di numeri interi. Per chiamarlo, assegnarlo a una variabile.

L'approccio qui è simile alla bella risposta Python di DenkerAffe . Otteniamo la rappresentazione binaria ndell'uso bin(n)e dividiamo la stringa risultante in tutte le corrispondenze dell'espressione regolare (?<=(.))(?=\1). In realtà è una partita di lunghezza zero; (?<=(.))è uno sguardo positivo che trova un singolo personaggio ed (?=\1)è uno sguardo positivo che trova il personaggio abbinato nello sguardo dietro. Questo individua i luoghi in cui un numero è seguito da solo nella rappresentazione binaria. Solo parseciascuno come un numero intero nella base 2 usando mape voilà!

C, 137 129 byte

main(){unsigned long a,b=scanf("%lu",&a),c=!!a;while(a>=b*2)b*=2;while(b)b/=2,c=c*(~(a^a/2)&b|!b?!printf("%lu\n",c):2)+!!(a&b);}

Ingresso e uscita sono sui flussi standard.

J , 16 byte

#:#.;.1~1,2=/\#:

Provalo online!

Spiegazione

#:#.;.1~1,2=/\#:  Input: integer n
              #:  Convert from decimal to list of binary digits
          2  \    For each overlapping sublist of size 2
           =/       Reduce using equals
        1,        Prepend 1
#:                Binary digits
    ;.1~          Partition those binary digits at the 1s in the previous list
  #.                Convert each partition from a list of binary digits to decimal

q / kdb +, 52 byte

Soluzione:

{2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}

Esempi:

q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}0
,0
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}1
,1
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}3
1 1
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}8
2 0 0
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}10000
2 1 1 2 0 2 0 0 0
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}12914
1 2 2 1 1 2 2
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}371017
5 42 10 2 1
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}727429805944311
10 21 2 5 1 1 1 1 1 2 1 2 5 1 85 5 1 1 1 5 1 1

Spiegazione:

q viene interpretato da destra a sinistra.

Trasmetti l'input in binario, taglia gli zeri iniziali, trova gli indici in modo diverso, inverti per ottenere gli indici in cui lo stesso, dividi la lista su questi indici, converti in base-10. Sembra un po 'pesante rispetto alla soluzione APL però ...

{2 sv'cut[0,where not differ a]a:(63^first where a)_a:0b vs x} / ungolfed solution
{                                                            } / lambda function
      cut[                    ]                                / cut a list at indices, cut[indices]list
                                                      0b vs x  / converts to 64bit binary representation
                                                    a:         / save as a
                                                   _           / drop 'n' elements from a
                                 (                )            / evaluate this
                                     first where a             / returns first occurance of true in list a
                                  63^                          / fill result with 63 if null (to handle input of 0)
                               a:                              / save as a, we've stripped off all the left-most 0s
                      differ a                                 / whether or not item in list a is different to previous
                  not                                          / the inversion of this result
            where                                              / these are the points where we have 00 or 11
          0,                                                   / add the first index too!
  2 sv'                                                        / 2 sv converts binary back to base-10, ' for each list

PHP, 147

$b=decbin($argv[1]);$a=[$t=$b[0]];$k=0;for($i=1;$i<strlen($b);$i++){$v=$b[$i];if($v==$t)$k++;$t=$v;$a[$k].=$v;}foreach($a as$c)echo bindec($c).' ';

È necessario aggiungere ulteriore spazio all'output poiché non vi sono restrizioni. Gli avvisi vengono visualizzati per la codifica breve.

Versione Ungolfed

$n=$argv[1];
$b=decbin($n);
$l=strlen($b);
$t=$b[0];
$a=[0=>$t];$k=0;
for($i=1;$i<$l;$i++){
    $v=$b[$i];
    if($v==$t){
        $k++;
    }
    $t=$v;$a[$k].=$v;    
}
foreach($a as $c){
    echo bindec($c).' ';
}

Retina, 60

+`(1+)\1
$1a
a1
1
(?<=(.))(?=\1)
¶
+`1(a*)\b
a$.1$*1;
a

;
1

Provalo online! Oppure prova una versione leggermente modificata per tutti i casi di test (con I / O decimale).

Sfortunatamente, le partite a lunghezza zero sembrano avere due "lati", causando la duplicazione quando usate con la regex dal terzo stadio. Tuttavia, costa solo un byte.

Accetta input come unario, output come unari. Non sono davvero sicuro di usare valori unari in / out diversi, ma ciò risparmierebbe 4 byte.

Gelatina , 9 byte (non competitiva?)

BI¬0;œṗBḄ

Provalo online!