Dato un numero, determinare se si tratta di un numero pieghevole.

Un numero pieghevole è un numero tale che se lo prendi rappresentazione binaria e lo "pieghi" a metà, questo è il risultato della moltiplicazione XNOR della prima metà del numero e della seconda metà con le cifre al contrario, otterrai zero.

Se il numero ha un numero dispari di cifre in binario, la sua cifra centrale deve essere 1 e viene ignorata durante la piegatura.

Dal momento che potrebbe essere un po 'confuso, darò alcuni esempi:

178

La rappresentazione binaria di 178 è

10110010

Per piegarlo, lo abbiamo prima diviso a metà

1011 0010

Invertire la seconda metà

1011
0100

E noi XNOR le due metà:

0000

Questo è zero, quindi questo è un numero pieghevole.

1644

La rappresentazione binaria del 1644 è

11001101100

Per piegarlo, lo abbiamo prima diviso a metà

11001 1 01100

Il bit centrale è 1, quindi lo buttiamo fuori.

11001 01100

Invertire la seconda metà

11001
00110

E noi XNOR le due metà:

00000

Questo è zero, quindi questo è un numero pieghevole.

4254

La rappresentazione binaria di 4254 è

1000010011110

Per piegarlo, lo abbiamo prima diviso a metà

100001 0 011110

Il bit centrale è 0, quindi questo non è un numero pieghevole.

Compito

Il tuo compito è quello di prendere un numero positivo e restituire una verità se il numero è pieghevole e falsa se non lo è. Questo è il golf del codice, quindi cerca di mantenere il conto alla rovescia del byte.

Casi test

Ecco i primi 99 numeri pieghevoli:

[1, 2, 6, 10, 12, 22, 28, 38, 42, 52, 56, 78, 90, 108, 120, 142, 150, 170, 178, 204, 212, 232, 240, 286, 310, 346, 370, 412, 436, 472, 496, 542, 558, 598, 614, 666, 682, 722, 738, 796, 812, 852, 868, 920, 936, 976, 992, 1086, 1134, 1206, 1254, 1338, 1386, 1458, 1506, 1596, 1644, 1716, 1764, 1848, 1896, 1968, 2016, 2110, 2142, 2222, 2254, 2358, 2390, 2470, 2502, 2618, 2650, 2730, 2762, 2866, 2898, 2978, 3010, 3132, 3164, 3244, 3276, 3380, 3412, 3492, 3524, 3640, 3672, 3752, 3784, 3888, 3920, 4000, 4032, 4222, 4318, 4462, 4558]

Gelatina , 9 byte

Bœs2µḢ^UȦ

Provalo online! o verifica tutti i casi di test .

Come funziona

Bœs2µḢ^UȦ  Main link. Argument: n

B          Binary; convert n to base 2.
 œs2       Evenly split 2; split the base 2 array into chunks of equal-ish length.
           For an odd amount of digits, the middle digit will form part of the
           first chunk.
    µ      Begin a new, monadic chain. Argument: [A, B] (first and second half)
     Ḣ     Head; remove and yield A.
       U   Upend; reverse the digits in [B].
      ^    Perform vectorized bitwise XOR of the results to both sides.
           If A is longer than B, the last digit will remain untouched.
           n is a folding number iff the result contains only 1's.
        Ȧ  Octave-style all; yield 1 iff the result does not contain a 0.

05AB1E , 13 12 byte

Codice:

bS2ä`R0¸«s^P

Utilizza la codifica CP-1252 . Provalo online!

Spiegazione:

Innanzitutto, convertiamo il numero in binario utilizzando b. 1644 diventa 11001101100 . Abbiamo diviso questo in due pezzi con 2ä. Ad esempio, 11001101100 diventerebbe:

[1, 1, 0, 0, 1, 1]
[0, 1, 1, 0, 0]

Se c'è un numero irregolare di bit, la prima parte riceverà il bit extra. Abbiamo REverse l'ultima stringa e aggiungere uno zero utilizzando 0¸«. Il motivo è quello di dare risultati veritieri solo quando il bit centrale è 1 ( 1 XOR 0 = 1 e 0 XOR 0 = 0 ). Se non è presente un bit intermedio, 05AB1E ignorerà solo l'ultimo bit (lo zero aggiunto):

[1, 1, 0, 0, 1, 1]
[0, 0, 1, 1, 0, 0]

L'ultima cosa che dobbiamo fare è fare un XOR saggio di elementi e prendere il prodotto del risultato. Se ci sono troppi elementi, il programma lascerà fuori l'ultimo elemento ( [1, 0, 0] XOR [0, 1] = [1, 1]) Ad esempio:

[1, 1, 0, 0, 1, 1]
[0, 0, 1, 1, 0, 0] XOR

diventa:

[1, 1, 1, 1, 1, 1]

E il prodotto di questo è 1 , che è vero.

Java 7, 152 145 142 138 134 byte

boolean f(Long a){byte[]b=a.toString(a,2).getBytes();int i=0,l=b.length,z=l%2<1?1:b[l/2]-48;for(;i<l/2;)z*=b[i]-b[l-++i];return z!=0;}

Avvolge la corda come se fosse un palindromo, alla ricerca di zero. Tiene traccia moltiplicando ripetutamente, quindi tutto ciò che devi fare è verificare che alla fine non sia zero.

Senza barre di scorrimento:

boolean f(Long a){
    byte[]b=a.toString(a,2).getBytes();
    int i=0,l=b.length,z=l%2<1?1:b[l/2]-48;
    for(;i<l/2;)
        z*=b[i]-b[l-++i];
    return z!=0;
}

JavaScript (ES6), 61 57 52 byte

Calcola ricorsivamente:

(bit(N) XOR bit(0)) AND (bit(N-1) XOR bit(1)) AND (bit(N-2) XOR bit(2)) etc.

dove si Ntrova il grado del bit più alto impostato nell'input.

Se l'input ha un numero dispari di bit, il bit centrale è XOR con un indefinito (il valore restituito da pop()un array vuoto), che lo lascia invariato. Quindi, un 0bit centrale cancella l'output e un 1bit centrale non altera il risultato delle altre operazioni, il che è coerente con la definizione di sfida di un numero pieghevole.

f=(n,[a,...b]=n.toString(2))=>a?(a^b.pop())&f(n,b):1

// testing integers in [1 .. 99]
for(var i = 1; i < 100; i++) {
  f(i) && console.log(i);
}

Python 2, 57 byte

s=bin(input())[2:]
while''<s!='1':s[-1]==s[0]<_;s=s[1:-1]

Uscite tramite codice di uscita : errore per Falsey e nessun errore per Truthy.

Converte l'input in binario. Verifica se il primo e l'ultimo carattere sono disuguali, lo mantiene e lo ripete dopo aver rimosso quei caratteri.

Il confronto s[-1]==s[0]<_fornisce un errore se il primo e l'ultimo carattere non sono uguali cercando di valutare la variabile non assegnata denominata _. Se sono uguali, la catena di disuguaglianze viene invece messa in corto circuito. Quando arriviamo all'elemento centrale di 1, il whileloop viene terminato nel caso speciale come OK.

Ho il sospetto che un approccio puramente aritmetico sarà più breve con una ricorsione come f=lambda n,r=0:...f(n/2,2*r+~n%2)...tagliare le cifre binarie dall'estremità capovolta e invertita, e rilevare quando ne rsono uguali fino a un centro 1. Ci sono sottigliezze con gli zeri iniziali e il centro.

Python 2, 94 79 72 67 byte

F=lambda s:s in'1'or(s[0]!=s[-1])*F(s[1:-1])
lambda n:F(bin(n)[2:])

12 byte salvati grazie a @xnor

Definisce una funzione senza nome sulla seconda riga.

Spiegazione (con alcuni spazi bianchi aggiunti):

F = lambda s:                                        # We define a function, F, which takes one argument, the string s, which returns the following:
             s in'1'                                 # Gives true if s is '' or s is '1', the first case is a base case and the second is for the middle bit case.
                     or(s[0] != s[-1])               # Or the first and last are different
                                      * F(s[1:-1])   # And check if s, without the first and last element is also foldable.
lambda n: F(bin(n)[:-2])                             # The main function, which calls F with the argument in binary form.

Provalo qui!

Haskell, 89 88 86 byte

f n|n<2=[n]|1>0=mod n 2:f(div n 2)
g n=elem(product$zipWith(+)(f n)$reverse$f n)[1,2]

Funziona sommando bitwise la rappresentazione bit con il suo rovescio e prendendo il prodotto. Se è 1 o 2, il numero è un numero di piegatura (1 se ci sono bit pari che si piegano, 2 se ci sono bit dispari e uno al centro).

Python 2, 100 99 95 94 byte

Mi sembra un po 'lungo, ma continuerò a lavorarci :) Stampa a 1se il numero può essere piegato, 0altrimenti.

a=bin(input())[2:]
b=len(a)
print(a[b/2]>=`b%2`)*all(c!=d for c,d in zip(a[:b/2],a[:~b/2:-1]))

^{Provalo qui!}

^{grazie a Wheat Wizard per il salvataggio di 1 byte :)}

^{grazie a Rod per il salvataggio di 5 byte! :)}

> <> , 37 + 3 = 40 byte

<,2-@:%2:v!?:
=2lrv?=1l<+={$r0?
0=n;>

Si prevede che l'input sia presente nello stack all'avvio del programma, quindi +3 byte per il -vflag.

Provalo online!

Gelatina , 13 byte

Bœs2U0¦z0^/€Ạ

TryItOnline
O termini corrispondenti fino a 4558

Come?

Bœs2U0¦z0^/€Ạ - Main link: n
B             - binary
 œs2          - split into 2 slices (odd length will have first longer than second)
     0¦       - apply to index 0 (the right hand one)
    U         - reverse
       z0     - zip together with filler 0 (thus central 1 or 0 will pair with 0)
          /€  - reduce with for each
         ^    -     XOR
            Ạ - All truthy?

Perl, 46 byte

Include +1 per -p

Esegui con il numero su STDIN

folding.pl <<< 178

folding.pl:

#!/usr/bin/perl -p
$_=($_=sprintf"%b",$_)<s%.%!/\G1$/^$&^chop%eg

Lo considero un bug perl che anche questo funziona. Interno $_non dovrebbe ricevere aggiornamenti sulla posizione della partita una volta modificato. In questo programma la posizione della partita si sposta effettivamente oltre la fine di$_

Brachylog , 16 byte

ḃḍ{↔|h1&b↔}ᵗz₂≠ᵐ

Non funziona abbastanza online ...

Riceve input attraverso la variabile input e output in caso di esito positivo o negativo. Fa molto affidamento z₂, che è nella lingua dal 30 aprile, ma ci siamo dimenticati di chiedere di averlo fatto su TIO, quindi per ora funziona solo su un'installazione locale della lingua. In entrambi i casi è probabilmente un approccio eccessivamente ingenuo.

                    The input
ḃ                   's binary representation
 ḍ                  split in half
  {       }ᵗ        with its second half
   ↔|               either reversed, or
     h1             if it starts with 1
       &b           relieved of its first element
         ↔          and then reversed
              ≠     has no duplicate elements
            z  ᵐ    in any pair of elements zipped from the two halves
             ₂      which are equal in length.

Brachylog (su TIO), 19 byte

ḃḍ{↔|h1&b↔}ᵗlᵛ↖Lz≠ᵐ

Provalo online!

lᵛ↖Lzè funzionalmente equivalente a z₂(se non si utilizza la variabile L altrove), ma è anche più lunga di tre byte.

Python 2, 76 71 69 byte

-5 byte grazie a @Dennis ( ''è presente in '1', quindi sostituiscilo in('','1')con in'1')
-2 byte grazie a @xnor (usa la moltiplicazione, (...)*al posto di and)

f=lambda n:f(bin(n)[2:])if n<''else n in'1'or(n[0]!=n[-1])*f(n[1:-1])

Ideone

La funzione ricorsiva, alla prima chiamata nè un numero, quindi viene valutata come inferiore alla stringa vuota, con if n<''e la funzione viene richiamata di nuovo, ma con ncast su una stringa binaria; la coda è una stringa vuota (anche la lunghezza di bit) o ​​il bit centrale, che restituisce true per vuoto o a '1'; su di esso la discesa si verifica i bit esterni per la disuguaglianza (equivalenti a XOR) e recurses sui bit interni, n[1:-1].

Python 2, 63 byte

s=bin(input())[2:]
while s[0]!=s[-1]:s=s[1:-1]or'1'
print'1'==s

Stampe Trueo False. Prende la rappresentazione binaria di se rimuove ripetutamente il primo e l'ultimo carattere purché non siano uguali. Verifica se ciò che rimane è la stringa vuota o una centrale 1. Questo viene fatto convertendo'' a '1'e controllando se il risultato è uguale '1', che evitano anche un errore indice sulla stringa vuota.

PowerShell v2 +, 143 byte

Due possibili approcci, entrambi con lo stesso numero di byte.

Metodo 1:

param($n)if($n-eq1){$n++}$o=1;0..(($b=($n=[convert]::ToString($n,2)).length-1)/2-!($b%2))|%{$o*=$n[$_]-ne$n[$b-$_]};$o*(+"$($n[$b/2])",1)[$b%2]

Accetta input $n , se è -eqnormale 1(un caso speciale per questo algoritmo), incrementalo. Impostare l' $output su 1(ovvero, assumere la verità), quindi 0eseguire il loop dal punto intermedio del numero di input che è stato modificato [convert]in binario. Nota -!($b%2)per tenere conto dei numeri binari di lunghezza dispari.

Ad ogni iterazione, confrontiamo la cifra corrente $n[$_] con la stessa lunghezza dalla fine $n[$b-$_]e moltiplichiamo il risultato booleano in $o(essenzialmente eseguendo un -andsu tutti). Una volta terminato il ciclo, dobbiamo potenzialmente tenere conto della cifra binaria centrale, che è la pseudo-ternaria alla fine (matrice indicizzata tramite $b%2). Quello 1o 0viene lasciato sulla pipeline e l'output è implicito.

Metodo 2:

param($n)for($n=[convert]::ToString($n,2);$n.Length-gt2){if($n[0]-ne$n[-1]){$n=$n[1..($n.Length-2)]}else{0;exit}}($n-join'+'|iex)-eq1-or$n-eq10

Accetta l'input e fa lo stesso processo con [convert]il numero in binario. Quindi siamo in un forciclo fintanto che la .lengthstringa binaria è -greater than 2. Quando siamo nel ciclo, se il primo $n[0]e l'ultimo $n[-1]cifre sono -not equal, tagliare quei due cifre fuori di $ne ri-store in $n. Altrimenti, output 0e exit. Una volta che siamo fuori dal giro, abbiamo o abbiamo (una serie di 1, 1,0, 0,1, per gli array e o stringhe o ). L'altra metà del test sta verificando se è reale (ovvero, input di1,1 , o 0,0), o la stringa binaria per due 10, o 3 11. Quindi, dobbiamo testare queste due possibilità. Per il primo, abbiamo -join $ninsieme+ e valutiamo il risultato e testiamo che sia1(questo vale per gli array 1, 1,0e0,1, ma è ). Quel booleano è rimasto sulla pipeline e l'output è implicito.$false0,01,11011-or$n-eq102

CJam , 13 byte

ri2b_W%.+:*3&

Provalo online! o genera un elenco di numeri pieghevoli fino a un determinato numero.

ri2b   e# convert input to binary
_W%.+  e# flip and sum (if folding all bits are 1 except middle)
:*     e# product is 0 or power of 2 (2 if middle folds)
3&     e# keep only 1 or 2, everything else becomes 0 (false)

MATL , 16 byte

tBn2/kW&\hBZ}P=~

Verità è un array con tutti. Controlla qui i criteri di verità / falsità .

Provalo online! Oppure verifica i primi 20 casi di test .

Spiegazione

Usiamo l'input 1644come esempio.

t     % Imolicitly take input. Duplicate
      %   STACK: 1644, 1644
Bn    % Number of digits of binary expansion
      %   STACK: 1644, 11
2/k   % Divide by 2 and round down
      %   STACK: 1644, 5
W     % 2 raised to that
      %   STACK: 1644, 32
&\    % Divmod
      %   STACK: 12, 51
h     % Concatenate horizontally
      %   STACK: [12 51]
B     % Binary expansion. Each numnber gives a row, left-padded with zeros if needed
      %   STACK: [0 0 1 1 0 0; 1 1 0 0 1 1]
Z}    % Split into rows
      %   STACK: [0 0 1 1 0 0], [1 1 0 0 1 1]
P     % Reverse
      %   STACK: [0 0 1 1 0 0], [1 1 0 0 1 1]
=~    % True for entries that have different elements
      %   STACK: [1 1 1 1 1 1]
      % Implicitly display

PHP, 101 byte

for($r=1;$i<($l=strlen($b=decbin($argv[1])))>>1;)$r*=$b[$i]^1^$b[$l-++$i]^1;$r*=$l%2?$b[$i]:1;echo$r;

o con registro

for($r=1,$s=log($n=$argv[1],2)^0;2*$i<$s;)$r*=($n>>$i)%2^($n>>$s-$i++)%2;$s%2?:$r*=($n>>$i)%2;echo$r;

108 byte con array

for($r=1,$a=str_split(decbin($argv[1]));$a;)$r*=array_pop($a)!=($a?array_shift($a):0);$r*=$a?$a[0]:1;echo$r;

Valori reali <10000

1,2,6,10,12,22,28,38,42,52,56,78,90,108,120,142,150,170,178,204,212,232,240,286,310,346,370,412,436,472,496,542,558,598,614,666,682,722,738,796,812,852,868,920,936,976,992,1086,1134,1206,1254,1338,1386,1458,1506,1596,1644,1716,1764,1848,1896,1968,2016,2110,2142,2222,2254,2358,2390,2470,2502,2618,2650,2730,2762,2866,2898,2978,3010,3132,3164,3244,3276,3380,3412,3492,3524,3640,3672,3752,3784,3888,3920,4000,4032,4222,4318,4462,4558,4726,4822,4966,5062,5242,5338,5482,5578,5746,5842,5986,6082,6268,6364,6508,6604,6772,6868,7012,7108,7288,7384,7528,7624,7792,7888,8032,8128,8318,8382,8542,8606,8814,8878,9038,9102,9334,9398,9558,9622,9830,9894

Julia , 66 byte

c(s)=s==""||s=="1"||(s[1]!=s[end]&&c(s[2:end-1]))
f(x)=c(bin(x))

Il mio primo golf! funziona allo stesso modo della soluzione Python della stessa lunghezza, con lievi differenze dovute al linguaggio (ce l'ho fatta da solo, però ...).

Spiegazione:

c(s) = s == "" || # Base case, we compared all the digits from 
                  # both halves.
       s == "1" || # We compared everything but left a 1 in the middle
       (s[1] != s[end] &&  # First digit neq last digit (XNOR gives 0).
        c(s[2:end-1]))     # AND the XNOR condition is satisfied for the  
                           # 2nd to 2nd to last digit substring.
f(x) = c(bin(x))  # Instead of a string f takes an integer now.

C, 223 201 189 194 178 byte

i,j,m,l,r;f(n){for(m=j=1,i=n;i/=2;++j);for(l=r=i=0;i<j/2;i++)r|=n&m?1<<j/2-i-1:0,m*=2;i=(j&1&&n&m)?i+1:(j&1)?l=r:i;n>>=i;for(m=1;i<j;i++)l|=n&m,m*=2;return !(~(l^r)&(1<<j/2)-1);}

Algoritmo di forza bruta. Vediamo fino a che punto può essere giocato a golf.

Migliorare le correzioni dei test di installazione ...

 main()
 {
    int t, s, u, testSet[] = 
    {
    1, 2, 6, 10, 12, 22, 28, 38, 42, 52, 56, 78, 90, 108, 120,
    142, 150, 170, 178, 204, 212, 232, 240, 286, 310, 346, 370,
    412, 436, 472, 496, 542, 558, 598, 614, 666, 682, 722, 738,
    796, 812, 852, 868, 920, 936, 976, 992, 1086, 1134, 1206,
    1254, 1338, 1386, 1458, 1506, 1596, 1644, 1716, 1764, 1848,
    1896, 1968, 2016, 2110, 2142, 2222, 2254, 2358, 2390, 2470,
    2502, 2618, 2650, 2730, 2762, 2866, 2898, 2978, 3010, 3132,
    3164, 3244, 3276, 3380, 3412, 3492, 3524, 3640, 3672, 3752,
    3784, 3888, 3920, 4000, 4032, 4222, 4318, 4462, 4558
    };


    for (u=s=0,t=1;t<=4558;t++)
    {
        if (f(t))
        {
          u++;            
          if (testSet[s++]!=t)
              printf("BAD VALUE %d %d\n", testSet[s-1], t);
        }
    }

    printf("%d == %d Success\n", u,
           sizeof(testSet)/sizeof(testSet[0]));

}

MATL , 13 byte

BttP=<~5Ms2<*

Verità è un array con tutti. Controlla qui i criteri di verità / falsità .

Provalo online!Oppure verifica i primi 20 casi di test .

Spiegazione

Utilizzo dell'input 1644come esempio:

B     % Implicit input. Convert to binary
      %   STACK: [1 1 0 0 1 1 0 1 1 0 0]
t     % Duplicate
      %   STACK: [1 1 0 0 1 1 0 1 1 0 0], [1 1 0 0 1 1 0 1 1 0 0]
tP=   % Element-wise compare each entry with that of the reversed array
      %   STACK: [1 1 0 0 1 1 0 1 1 0 0], [0 0 0 0 0 1 0 0 0 0 0]
<~    % True (1) if matching entries are equal or greater
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1]
5M    % Push array of equality comparisons again
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1], [0 0 0 0 0 1 0 0 0 0 0]
s     % Sum of array
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1], 1
2<    % True (1) if less than 2
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1], 1
*     % Multiply
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1]
      % Implicitly display

JavaScript, 71 byte

(i,n=i.toString(2))=>/^(1*)2?\1$/.test(+n+ +n.split``.reverse().join``)

Definisce una funzione anonima.

Questo metodo potrebbe non essere il più breve, ma per quanto ne so, è unico. Aggiunge il numero in binario a se stesso invertito, trattandoli come decimali, quindi controllando se il risultato è valido usando una regex.

Retina, 92 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

.+
$*
+`(1+)\1
${1}0
01
1
^((.)*?)1??((?<-2>.)*$.*)
$1¶$3
O$^`.(?=.*¶)

T`01`10`^.*
^(.*)¶\1

Provalo online

Converti in unario. Converti quello in binario. Taglia il numero a metà e rimuovi un centro 1se c'è. Invertire la prima metà. Cambia quelli e gli zeri. Abbina se entrambe le metà sono uguali.

Retina, 71 70 60 byte

.+
$*
+`^(1*)\1(1?)\b
$1 $.2
+`^ (.)(.*) (?!\1).$
$2
^( 1)?$

Probabilmente ho ancora molto da imparare su Retina (ad esempio regex ricorsivo?). Spiegazione: Il passaggio 1 converte da decimale a unario. Il passaggio 2 converte da unario a pseudo-binario. Il passaggio 3 rimuove le cifre da entrambe le estremità purché non corrispondano. Il quarto passo corrisponde a un 1 finale centrale opzionale se necessario. Modifica: salvato 1 byte grazie a @ mbomb007. Ho salvato 10 byte migliorando la mia conversione da unaria a binaria.

Python 2, 61 59 byte

Salvataggio di due byte per convertire i turni in moltiplicazioni

m=n=input()
i=0
while m:i*=2;i+=m&1;m/=2
print(n+i+1)&(n+i)

Restituisce 0per un numero pieghevole e qualsiasi altra cosa per non pieghevole. Utilizza l'approccio bit-twiddling.

C, 65 63 byte

Due byte per convertire i turni in moltiplicazioni

i,m;
f(n){
 m=n;i=0;
 while(m)i*=2,i+=m&1,m/=2;
 return(n+i+1)&(n+i);
}

Lo spazio bianco è già escluso da Bytecount, restituisce 0 per un numero pieghevole e qualsiasi altra cosa per non pieghevole. Utilizza l'approccio bit-twiddling.

k, 77 byte

{X:2 0N#X@&:|\X:0b\:x;c:#:'X;$[(~*X 1)|(=). c;~|/(=).(::;|:)@'(-&/ c)#'X;0b]}

a titolo esplicativo, una traduzione in q

{X:2 0N#X where maxs X:0b vs x;
  c:count each X;
  $[(not first last X)or(=). c;
    not any(=).(::;reverse)@'(neg min c)#'X;0b]
  };