Étant donné un numéro, déterminez s'il s'agit d'un numéro pliant.

Un numéro de pliage est un nombre tel que si vous prenez une représentation binaire et que vous le "pliez" en deux, c'est-à-dire que vous prenez le résultat de la multiplication XNOR de la première moitié du nombre et de la seconde moitié avec les chiffres en sens inverse, vous obtiendrez zéro.

Si le nombre a un nombre impair de chiffres en binaire, le chiffre du milieu doit être 1 et est ignoré lors du pliage.

Comme cela peut paraître un peu déroutant, je vais donner quelques exemples:

178

La représentation binaire de 178 est

10110010

Pour plier cela nous l'avons d'abord divisé en deux

1011 0010

Nous inversons la seconde moitié

1011
0100

Et nous XNOR les deux moitiés:

0000

C'est zéro donc c'est un nombre pliant.

1644

La représentation binaire de 1644 est

11001101100

Pour plier cela nous l'avons d'abord divisé en deux

11001 1 01100

Le bit du milieu est 1 alors nous le jetons.

11001 01100

Nous inversons la seconde moitié

11001
00110

Et nous XNOR les deux moitiés:

00000

C'est zéro donc c'est un nombre pliant.

4254

La représentation binaire de 4254 est

1000010011110

Pour plier cela nous l'avons d'abord divisé en deux

100001 0 011110

Le bit du milieu est 0, donc ce n'est pas un numéro de pliage.

Tâche

Votre tâche consiste à accepter un nombre positif et à renvoyer une vérité si le nombre est plié et faux si ce n’est pas le cas. C’est du code golf, alors essayez de garder le décompte des octets.

Cas de test

Voici les 99 premiers numéros pliants:

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

Gelée , 9 octets

Bœs2µḢ^UȦ

Essayez-le en ligne! ou vérifier tous les cas de test .

Comment ça marche

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 octets

Code:

bS2ä`R0¸«s^P

Utilise le codage CP-1252 . Essayez-le en ligne!

Explication:

Premièrement, nous convertissons le nombre en binaire en utilisant b. 1644 devient 11001101100 . Nous divisons cela en deux morceaux avec 2ä. Par exemple, 11001101100 deviendrait:

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

S'il y a un nombre impair de bits, la première partie recevra le bit supplémentaire. Nous Rinversons la dernière chaîne et ajoutons un zéro en utilisant 0¸«. La raison en est de ne donner des résultats de vérité que lorsque le bit du milieu est un 1 ( 1 XOR 0 = 1 et 0 XOR 0 = 0 ). S'il n'y a pas de bit du milieu, 05AB1E ignorera simplement le dernier bit (le zéro ajouté):

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

La dernière chose que nous devons faire est de faire un XOR élément par élément et de prendre le produit du résultat. S'il y a un élément de trop, le programme laissera simplement le dernier élément sur ( [1, 0, 0] XOR [0, 1] = [1, 1]) Par exemple:

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

Devient:

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

Et le produit de cela est 1 , qui est la vérité.

Java 7, 152 145 142 138 134 octets

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

Des boucles sur la ficelle comme pour un palindrome, à la recherche de zéros. Garde la trace en se multipliant à plusieurs reprises, il suffit donc de vérifier que ce n'est pas nul à la fin.

Sans barres de défilement:

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 octets

Calcule récursivement:

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

où Nest le rang du bit le plus élevé défini dans l'entrée.

Si l'entrée a un nombre impair de bits, le bit du milieu est marqué XOR avec indéfini (la valeur renvoyée par pop()sur un tableau vide), ce qui la laisse inchangée. Ainsi, un 0bit du milieu efface la sortie et un 1bit du milieu ne modifie pas le résultat des autres opérations - ce qui est cohérent avec la définition de défi d'un numéro de pliage.

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 octets

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

Sorties via le code de sortie : erreur pour Falsey et aucune erreur pour Truthy.

Convertit l'entrée en binaire. Vérifie si le premier et le dernier caractère sont inégaux, le garde et le répète après avoir supprimé ces caractères.

La comparaison s[-1]==s[0]<_génère une erreur si les premier et dernier caractères sont inégaux en essayant d'évaluer la variable non affectée nommée _. S'ils sont égaux, la chaîne d'inégalités est court-circuitée. Lorsque nous arrivons à l’élément central de 1, la whileboucle se termine dans les cas particuliers de manière satisfaisante.

Je soupçonne qu'une approche purement arithmétique sera plus courte avec une récursion comme f=lambda n,r=0:...f(n/2,2*r+~n%2)...pour chomper les chiffres binaires à partir de la fin retournés et inversés, et détecter quand net rsont égaux jusqu'à un centre 1. Il existe cependant des subtilités avec les zéros et le centre.

Python 2, 94 79 72 67 octets

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

12 octets sauvés grâce à @xnor

Définit une fonction non nommée sur la deuxième ligne.

Explication (avec quelques espaces ajoutés):

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.

Essayez-le ici!

Haskell, 89 88 86 octets

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]

Fonctionne en sommant au bit la représentation du bit avec son inverse et en prenant le produit. S'il s'agit de 1 ou 2, le nombre est un numéro de pliage (1 s'il y a des bits pairs qui se plient, 2 s'il y a des bits impairs et un un au milieu).

Python 2, 100 99 95 94 octets

Cela semble un peu long, mais je vais continuer à y travailler :) Imprime un 1si le nombre peut être plié, 0sinon.

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

^{Testez-le ici!}

^{grâce à Wheat Wizard pour la sauvegarde sur 1 octet :)}

^{merci à Rod pour la sauvegarde de 5 octets! :)}

> <> , 37 + 3 = 40 octets

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

L'entrée devrait être présente sur la pile au début du programme, donc +3 octets pour le -vdrapeau.

Essayez-le en ligne!

Gelée , 13 octets

Bœs2U0¦z0^/€Ạ

TryItOnline
Ou termes équivalents jusqu'à 4558

Comment?

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 octets

Comprend +1 pour -p

Exécuter avec le numéro sur STDIN

folding.pl <<< 178

folding.pl:

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

Je considère comme un bogue de Perl que cela fonctionne même. Internal $_ne devrait pas recevoir de mises à jour de position de correspondance une fois celle-ci modifiée. Dans ce programme, la position du match dépasse réellement la fin du$_

Brachylog , 16 octets

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

Cela ne fonctionne pas tout à fait en ligne ...

Prend les entrées via la variable d'entrée et les sorties en cas de succès ou d'échec. Cela dépend énormément z₂, qui est dans la langue depuis le 30 avril, mais nous avons oublié de demander de la tirer sur TIO afin que cela ne fonctionne pour le moment que sur une installation locale de la langue. De toute façon, c'est probablement une approche trop naïve.

                    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 (sur TIO), 19 octets

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

Essayez-le en ligne!

lᵛ↖Lzest fonctionnellement équivalent à z₂(si vous n'utilisez pas la variable L ailleurs), mais il est également trois octets plus long.

Python 2, 76 71 69 octets

-5 octets grâce à @Dennis ( ''est présent dans '1', remplacez-le in('','1')par in'1')
-2 octets grâce à @xnor (multiplication d'utilisation (...)*à la place de and)

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

Ideone

Recursive function, upon first call n is a number so it evaluates as less than the empty string, with if n<'', and the function is called again but with n cast to a binary string; the tail is either an empty string (even bit-length) or the middle bit, which returns true for empty or a '1'; on it's way down it tests the outer bits for inequality (equivalent to XOR) and recurses on the inner 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

Prints True or False. Takes the binary representation of s and repeatedly removed the first and last characters as long as they are unequal. Checks whether what remains is the empty string or a central 1. This is done by converting '' to '1' and checking if the result equals '1', which also avoid an index error on the empty string.

PowerShell v2+, 143 bytes

Two possible approaches, both the same byte count.

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

Takes input $n, if it's -equal to 1 (a special case for this algorithm), increment it. Set $output to be 1 (i.e., assume truthy), then loop from 0 to the midway point of the input number that has been [convert]ed to binary. Note the -!($b%2) to account for odd length binary numbers.

Each iteration, we compare the current digit $n[$_] with the digit the same length from the end $n[$b-$_], and multiply the Boolean result into $o (essentially performing an -and on all of them). Once the loop is done, we need to potentially account for the middle binary digit, that's the pseudo-ternary at the end (array indexed via $b%2). That 1 or 0 is left on the pipeline, and output is implicit.

Method 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

Takes input and does the same process to [convert] the number to binary. Then we're in a for loop so long as the .length of the binary string is -greaterthan 2. When we're in the loop, if the first $n[0] and last $n[-1] digits are -notequal, slice those two digits off of $n and re-store it into $n. Otherwise, output 0 and exit. Once we're out of the loop, we either have (an array of 1, 1,0, 0,1, 1,1, or 0,0), or the binary string for two 10, or 3 11. So, we need to test those two possibilities. For the first, we -join $n together with + and evaluate the result and test that it's 1 (this is true for arrays 1, 1,0, and 0,1, but is $false for arrays 0,0 and 1,1 or strings 10 or 11). The other half of the -or is testing whether $n is -equal to 10 (i.e., input of 2). That Boolean is left on the pipeline, and output is implicit.

CJam, 13 bytes

ri2b_W%.+:*3&

Try it online! or generate a list of folding numbers up to a given number.

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=~

Truthy is an array with all ones. Check truthy/falsy criteria here.

Try it online! Or Verify the first 20 test cases.

Explanation

Let's use input 1644 as an example.

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;

or with 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 with 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;

True values <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))

My first golf! works the same way as the Python solution of the same length, minor differences due to language (I did come up with it on my own, though...).

Explanation:

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 algorithm. Let's see how far it can be golfed.

Better test setup bugfixes...

 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<*

Truthy is an array with all ones. Check truthy/falsy criteria here.

Try it online! Or verify the first 20 test cases.

Explanation

Using input 1644 as an example:

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

Defines an anonymous function.

This method may not be the shortest, but as far as I know, it is unique. It adds the number in binary to itself reversed, treating them as decimal, then checking if the result is valid using a regex.

Retina, 92 bytes

Byte count assumes ISO 8859-1 encoding.

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

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

Try it online

Convert to unary. Convert that to binary. Cut the number in half and remove a middle 1 if there is. Reverse the first half. Switch its ones and zeros. Match if both halves are equal.

Retina, 71 70 60 bytes

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

I probably still have a lot to learn about Retina (e.g. recursive regex?). Explanation: Step 1 converts from decimal to unary. Step 2 converts from unary to pseudo-binary. Step 3 removes digits from both ends as long as they mismatch. Step four matches an optional final central 1 if necessary. Edit: Saved 1 byte thanks to @mbomb007. Saved 10 bytes by improving my unary to binary conversion.

Python 2, 61 59 bytes

Saving two bytes for converting shifts to multiplications

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

Returns 0 for a folding number and anything else for non-folding. Uses the bit-twiddling approach.

C, 65 63 bytes

Two bytes for converting shifts to multiplications

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

Whitespace is already excluded from bytecount, returns 0 for a folding number and anything else for non-folding. Uses the bit-twiddling approach.

k, 77 bytes

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

by way of explanation, a translation to 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]
  };