Bestimmen Sie anhand einer gegebenen Zahl, ob es sich um eine Falznummer handelt.

Eine Falzzahl ist eine Zahl, bei der Sie, wenn Sie sie als Binärdarstellung betrachten und in zwei Hälften "falten", das Ergebnis einer XNOR-Multiplikation der ersten Hälfte der Zahl und der zweiten Hälfte mit umgekehrten Ziffern erhalten Null.

Wenn die Zahl eine ungerade Anzahl von Ziffern im Binärformat hat, muss die mittlere Ziffer 1 sein und wird beim Falten ignoriert.

Da dies etwas verwirrend sein könnte, möchte ich einige Beispiele nennen:

178

Die binäre Darstellung von 178 ist

10110010

Um dies zu falten, teilen wir es zuerst in zwei Hälften

1011 0010

Wir kehren die zweite Hälfte um

1011
0100

Und wir XNOR die beiden Hälften:

0000

Dies ist Null, das ist also eine Faltzahl.

1644

Die binäre Darstellung von 1644 ist

11001101100

Um dies zu falten, teilen wir es zuerst in zwei Hälften

11001 1 01100

Das mittlere Bit ist 1, also werfen wir es raus.

11001 01100

Wir kehren die zweite Hälfte um

11001
00110

Und wir XNOR die beiden Hälften:

00000

Dies ist Null, das ist also eine Faltzahl.

4254

Die binäre Darstellung von 4254 ist

1000010011110

Um dies zu falten, teilen wir es zuerst in zwei Hälften

100001 0 011110

Das mittlere Bit ist 0, dies ist also keine Falzzahl.

Aufgabe

Ihre Aufgabe ist es, eine positive Zahl aufzunehmen und eine Wahrheit zurückzugeben, wenn die Zahl richtig und falsch ist, wenn sie nicht richtig ist. Dies ist Codegolf, also versuchen Sie, den Byte-Countdown niedrig zu halten.

Testfälle

Hier sind die ersten 99 Klappnummern:

[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]

Gelee , 9 Bytes

Bœs2µḢ^UȦ

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

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 Bytes

Code:

bS2ä`R0¸«s^P

Verwendet die CP-1252- Codierung. Probieren Sie es online!

Erläuterung:

Zuerst konvertieren wir die Zahl mit in binär b. 1644 wird 11001101100 . Wir teilen dies in zwei Teile mit 2ä. Beispielsweise würde 11001101100 :

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

Bei einer ungeraden Anzahl von Bits erhält der erste Teil das zusätzliche Bit. Wir Rkehren die letzte Zeichenfolge um und fügen mit eine Null an 0¸«. Der Grund dafür ist, nur dann wahrheitsgemäße Ergebnisse zu liefern, wenn das mittlere Bit eine 1 ist ( 1 XOR 0 = 1 und 0 XOR 0 = 0 ). Wenn es kein mittleres Bit gibt, ignoriert 05AB1E nur das letzte Bit (die angehängte Null):

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

Das Letzte, was wir tun müssen, ist ein elementweises XOR durchzuführen und das Produkt des Ergebnisses zu nehmen. Wenn ein Element zu viele Elemente enthält, lässt das Programm das letzte Element einfach weg ( [1, 0, 0] XOR [0, 1] = [1, 1]). Beispiel:

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

Wird:

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

Und das Produkt davon ist 1 , was wahr ist.

Java 7, 152 145 142 138 134 Bytes

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;}

Durchläuft die Zeichenfolge wie bei einem Palindrom und sucht nach Nullen. Behalten Sie den Überblick, indem Sie wiederholt multiplizieren. Sie müssen also nur überprüfen, ob es am Ende nicht Null ist.

Ohne Bildlaufleisten:

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 Bytes

Berechnet rekursiv:

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

wo Nist der Rang des höchsten gesetzten Bits in der Eingabe.

Wenn der Eingang eine ungerade Anzahl von Bits hat, wird das mittlere Bit mit undefined (der von pop()einem leeren Array zurückgegebene Wert) XOR-verknüpft , wodurch es unverändert bleibt . Ein 0mittleres Bit löscht also die Ausgabe und ein 1mittleres Bit ändert das Ergebnis der anderen Operationen nicht - was mit der Herausforderungsdefinition einer Faltzahl konsistent ist.

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 Bytes

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

Ausgabe über Exit-Code : Fehler bei Falsey und kein Fehler bei Truthy.

Wandelt die Eingabe in eine Binärdatei um. Überprüft, ob das erste und das letzte Zeichen ungleich sind, und wiederholt dies, nachdem diese Zeichen entfernt wurden.

Der Vergleich s[-1]==s[0]<_gibt einen Fehler aus, wenn das erste und das letzte Zeichen ungleich sind, indem versucht wird, die nicht zugewiesene Variable mit dem Namen auszuwerten _. Wenn sie gleich sind, wird stattdessen die Kette der Ungleichungen kurzgeschlossen. Wenn wir zum mittleren Element von kommen 1, wird die whileSchleife beendet, um den Sonderfall als OK zu kennzeichnen.

Ich vermute, dass ein rein arithmetischer Ansatz kürzer sein wird, wenn eine Rekursion f=lambda n,r=0:...f(n/2,2*r+~n%2)...Binärziffern von dem Ende abschneidet, das gespiegelt und umgekehrt ist, und erkennt, wann nund rgleich einem Zentrum ist 1. Es gibt jedoch Feinheiten mit führenden Nullen und der Mitte.

Python 2, 94 79 72 67 Bytes

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

12 Bytes dank @xnor gespart

Definiert eine unbenannte Funktion in der zweiten Zeile.

Erklärung (mit etwas Leerzeichen):

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.

Probieren Sie es hier aus!

Haskell, 89 88 86 Bytes

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]

Arbeitet, indem bitweise die Bitdarstellung mit ihrer Rückseite summiert und das Produkt genommen wird. Wenn es 1 oder 2 ist, ist die Zahl eine faltende Zahl (1, wenn es gerade Bits gibt, die falten, 2, wenn es ungerade Bits gibt und eine Eins in der Mitte).

Python 2, 100 99 95 94 Bytes

Das fühlt sich ein bisschen lang an, aber ich werde weiter daran arbeiten :) Druckt ein, 1wenn die Zahl gefaltet werden kann, 0ansonsten.

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]))

^{Teste es hier!}

^{danke an Wheat Wizard für die 1-Byte-Speicherung :)}

^{Danke an Rod für die 5-Byte-Speicherung! :)}

> <> , 37 + 3 = 40 Bytes

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

Es wird erwartet, dass die Eingabe beim Programmstart auf dem Stack vorhanden ist, also +3 Byte für das -vFlag.

Probieren Sie es online!

Jelly , 13 Bytes

Bœs2U0¦z0^/€Ạ

TryItOnline
Oder passende Begriffe bis zu 4558

Wie?

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 Bytes

Beinhaltet +1 für -p

Führen Sie mit der Nummer auf STDIN

folding.pl <<< 178

folding.pl:

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

Ich halte es für einen Perl-Fehler, dass dies sogar funktioniert. Interne $_sollten keine Aktualisierungen der Übereinstimmungsposition erhalten, sobald sie geändert wurden. In diesem Programm springt die Matchposition tatsächlich über das Ende von hinaus$_

Brachylog , 16 Bytes

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

Es funktioniert nicht ganz online ...

Übernimmt die Eingabe über die Eingabevariable und gibt sie über Erfolg oder Misserfolg aus. Es stützt sich stark auf z₂die Sprache, die seit dem 30. April verfügbar ist, aber wir haben vergessen zu fragen, ob TIO darauf zugegriffen werden soll. Derzeit funktioniert dies nur bei einer lokalen Installation der Sprache. So oder so ist es wahrscheinlich eine zu naive Herangehensweise.

                    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 (auf TIO), 19 Bytes

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

Probieren Sie es online!

lᵛ↖Lzist funktional äquivalent zu z₂(wenn Sie die Variable L nirgendwo anders verwenden), aber es ist auch drei Bytes länger.

Python 2, 76 71 69 Bytes

-5 Bytes dank @Dennis ( ''ist vorhanden in '1', also ersetzen in('','1')durch in'1')
-2 Bytes dank @xnor (verwenden Sie die Multiplikation (...)*anstelle von and)

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

Ideone

Bei der rekursiven Funktion wird beim ersten Aufruf neine Zahl als kleiner als die leere Zeichenfolge mit ausgewertet if n<'', und die Funktion wird erneut aufgerufen, jedoch nin eine binäre Zeichenfolge umgewandelt. Das Ende ist entweder eine leere Zeichenfolge (gerade Bitlänge) oder das mittlere Bit, das true für empty oder a zurückgibt '1'. Auf dem Weg nach unten prüft es die äußeren Bits auf Ungleichheit (entspricht XOR) und rekursiv auf die inneren Bits n[1:-1].

Python 2, 63 Bytes

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

Druckt Trueoder False. Übernimmt die Binärdarstellung des sersten und letzten Zeichens und entfernt sie wiederholt, solange sie ungleich sind. Prüft, ob der leere String oder ein zentraler übrig bleibt 1. Dies erfolgt durch Konvertieren ''in '1'und Überprüfen, ob das Ergebnis gleich ist '1', wodurch auch ein Indexfehler für die leere Zeichenfolge vermieden wird.

PowerShell v2 +, 143 Byte

Zwei mögliche Ansätze, beide die gleiche Byteanzahl.

Methode 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]

Nimmt Eingaben vor $n, wenn dies der -eqFall ist 1(ein Sonderfall für diesen Algorithmus), erhöhen Sie ihn. Setzen Sie $output auf 1(dh nehmen Sie an, dass es wahr ist), und führen Sie dann eine Schleife von 0bis zur Mitte der Eingabezahl durch, die [convert]auf binär gesetzt wurde. Beachten Sie das -!($b%2), um Binärzahlen mit ungerader Länge zu berücksichtigen.

Bei jeder Iteration vergleichen wir die aktuelle Ziffer $n[$_]mit der Ziffer, die vom Ende an die gleiche Länge hat $n[$b-$_], und multiplizieren das Boolesche Ergebnis mit $o(im Grunde genommen führen wir ein -andauf alle von ihnen aus). Sobald die Schleife beendet ist, müssen wir möglicherweise die mittlere Binärziffer berücksichtigen, das ist der Pseudoternär am Ende (Array indiziert über $b%2). Das 1oder 0wird in der Pipeline belassen, und die Ausgabe ist implizit.

Methode 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

Übernimmt die Eingabe und führt den gleichen Vorgang aus, um [convert]die Zahl zu binären. Dann sind wir in einer forSchleife, solange die .lengthvon der binären Zeichenfolge -größere than 2. Wenn wir in der Schleife sind, wenn die ersten $n[0]und letzten $n[-1]Ziffern sind -not equal, in Scheiben schneiden , diese beiden Ziffern weg von $nund wieder speichern es in $n. Ansonsten Ausgabe 0und exit. Sobald wir die Schleife unterwegs sind, haben wir entweder (eine Reihe von 1, 1,0, 0,1, 1,1, oder 0,0) oder das binären Zeichenfolge für zwei 10oder 3 11. Wir müssen also diese beiden Möglichkeiten testen. Zum einen bewerten wir -join $ngemeinsam mit +und das Ergebnis und testen, dass es ist1(Dies gilt für Arrays 1, 1,0und 0,1, aber $falsefür Arrays 0,0und / 1,1oder Strings 10oder 11). Die andere Hälfte der -ortestet , ob $nist -eqUAL zu 10(dh Eingang 2). Dieser Boolesche Wert verbleibt in der Pipeline, und die Ausgabe ist implizit.

CJam , 13 Bytes

ri2b_W%.+:*3&

Probieren Sie es online! oder erstellen Sie eine Liste mit Falznummern bis zu einer bestimmten Nummer.

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 Bytes

tBn2/kW&\hBZ}P=~

Wahrheit ist ein Array mit allen. Überprüfen Sie hier die Wahrheitskriterien .

Probieren Sie es online! Oder Überprüfen Sie die ersten 20 Testfälle .

Erläuterung

Verwenden wir 1644als Beispiel die Eingabe .

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 Bytes

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;

oder mit log

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 Bytes mit 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;

Wahre Werte <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 Bytes

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

Mein erstes Golf! Funktioniert genauso wie die Python-Lösung von gleicher Länge, kleine sprachliche Unterschiede (ich habe es mir aber selbst ausgedacht ...).

Erläuterung:

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 Bytes

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);}

Brute-Force-Algorithmus. Mal sehen, wie weit es golfen kann.

Bessere Bugfixes für das Test-Setup ...

 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 Bytes

BttP=<~5Ms2<*

Wahrheit ist ein Array mit allen. Überprüfen Sie hier die Wahrheitskriterien .

Probieren Sie es online! Oder überprüfen Sie die ersten 20 Testfälle .

Erläuterung

Verwenden Sie die Eingabe 1644als Beispiel:

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 Bytes

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

Definiert eine anonyme Funktion.

Diese Methode ist vielleicht nicht die kürzeste, aber meines Wissens ist sie einzigartig. Es addiert die Zahl in binärer Form in umgekehrter Reihenfolge zu sich selbst, behandelt sie als Dezimalzahl und prüft dann mithilfe eines regulären Ausdrucks, ob das Ergebnis gültig ist.

Netzhaut, 92 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

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

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

Probieren Sie es online aus

In Unary konvertieren. Wandle das in eine Binärdatei um. Schneiden Sie die Zahl in zwei Hälften und entfernen Sie eine Mitte, 1falls vorhanden. Kehren Sie die erste Hälfte um. Schalten Sie die Einsen und Nullen. Spiel, wenn beide Hälften gleich sind.

Retina, 71 70 60 Bytes

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

Ich muss wahrscheinlich noch viel über Retina lernen (zB rekursiver regulärer Ausdruck?). Erläuterung: In Schritt 1 wird von dezimal nach unär konvertiert. Schritt 2 konvertiert von unär zu pseudobinär. In Schritt 3 werden Ziffern von beiden Enden entfernt, solange sie nicht übereinstimmen. Schritt vier entspricht bei Bedarf einer optionalen letzten zentralen 1. Bearbeiten: 1 Byte dank @ mbomb007 gespeichert. Sparte 10 Bytes, indem ich meine Konvertierung von unär nach binär verbesserte.

Python 2, 61 59 Bytes

Speichern von zwei Bytes zum Konvertieren von Verschiebungen in Multiplikationen

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

Kehrt 0für eine Falznummer und für alles andere für das Nicht-Falzen zurück. Verwendet den Bit-Twiddling-Ansatz.

C 65 63 Bytes

Zwei Bytes zum Umwandeln von Verschiebungen in Multiplikationen

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

Whitespace ist bereits von bytecount ausgeschlossen, gibt 0 für eine Falzzahl und alles andere für ein Nicht-Falzen zurück. Verwendet den Bit-Twiddling-Ansatz.

k, 77 Bytes

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

zur Erklärung eine Übersetzung zu 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]
  };