Un intero positivo N è K -sparse se ci sono almeno K 0 tra due qualsiasi 1 consecutivi nella sua rappresentazione binaria.

Quindi, il numero 1010101 è 1-sparse mentre 101101 non lo è.

Il tuo compito è trovare il prossimo numero 1-sparse per il numero di input specificato. Ad esempio, se l'ingresso è 12 (0b1100 ) l'output dovrebbe essere 16 ( 0b10000) e se l'ingresso è 18 ( 0b10010) l'output dovrebbe essere 20 ( 0b10100).

Il programma o la funzione più piccolo (in byte) vince! Scappatoie standard non consentite.

Pyth, 9 byte

• Prendendo in prestito l' x & (x*2) != 0algoritmo da @alephalpha
• Prendendo in prestito Pyth boilerplate da @Jakube

Il mio primo tentativo di Pyth:

f!.&TyThQ

Provalo qui

               implicit: Q = input()            
f      hQ      find the first integer T >= Q + 1, 
               that satisfies the condition:
 !.&TyT        T & (T * 2) is 0

CJam, 14 11 byte

3 byte salvati grazie a DigitalTrauma.

l~{)___+&}g

Provalo qui.

Spiegazione

l~          "Read and eval input.";
  {      }g "Do while...";
   )_       "Increment and duplicate (call this x).";
     __+    "Get two more copies and add them to get x and 2x on the stack.";
        &   "Take their bitwise AND. This is non-zero is as long as x's base-2
             representation contains '11'.";

Questo lascia l'ultimo numero sulla pila che viene stampato automaticamente alla fine del programma.

Python 2, 44 byte

Questo è un programma Python completo che legge in n e stampa la risposta. Penso che lo faccia abbastanza bene nella sotto-competizione di leggibilità.

n=input()+1
while'11'in bin(n):n+=1
print n

I risultati del test:

$ echo 12 | python soln.py 
16
$ echo 18 | python soln.py 
20

Pyth, 12 11 byte

f!}`11.BThQ

Provalo online: Pyth Compiler / Executor .

               implicit: Q = input()            
f        hQ    find the first integer T >= Q + 1, 
               that satisfies the condition:
 !}`11.BT         "11" is not in the binary representation of T

Mathematica, 41 30 byte

Risparmiato 11 byte grazie a Martin Büttner.

#+1//.i_/;BitAnd[i,2i]>0:>i+1&

Perl, 31

#!perl -p
sprintf("%b",++$_)=~/11/&&redo

O dalla riga di comando:

 perl -pe'sprintf("%b",++$_)=~/11/&&redo' <<<"18"

APL, 18 byte

1∘+⍣{~∨/2∧/⍺⊤⍨⍺⍴2}

Questo valuta una funzione monadica. Provalo qui. Uso:

   1∘+⍣{~∨/2∧/⍺⊤⍨⍺⍴2} 12
16

Spiegazione

1∘+                    ⍝ Increment the input ⍺
   ⍣{            }     ⍝ until
     ~∨/               ⍝ none of
        2∧/            ⍝ the adjacent coordinates contain 1 1 in
           ⍺⊤⍨⍺⍴2      ⍝ the length-⍺ binary representation of ⍺.

J, 20 caratteri

Un verbo monadico. Risolto per obbedire alle regole.

(+1 1+./@E.#:)^:_@>:

Spiegazione

Innanzitutto, questo è il verbo con spazi e poi un po 'meno golf:

(+ 1 1 +./@E. #:)^:_@>:
[: (] + [: +./ 1 1 E. #:)^:_ >:

Leggere:

    ]                             The argument
      +                           plus
        [: +./                    the or-reduction of
               1 1 E.             the 1 1 interval membership in
                      #:          the base-2 representation of the argument,
[: (                    )^:_      that to the power limit of
                             >:   the incremented argument

L'argomento più la riduzione or dell'appartenenza 1 1all'intervallo nella rappresentazione base-2 dell'argomento, che al limite di potenza si applicava all'argomento incrementato.

Fondamentalmente computo se si 1 1verifica nella rappresentazione base-2 dell'input. In tal caso, incremento l'input. Questo è sottoposto a un limite di potenza, il che significa che viene applicato fino a quando il risultato non cambia più.

Javascript, 25 19

Sfruttando il fatto che per un numero binario 1-sparse x&2*x == 0:

f=x=>x++&2*x?f(x):x

JavaScript (ES6), 39 43

Nessuna regexp, nessuna stringa, ricorsiva:

R=(n,x=3)=>x%4>2?R(++n,n):x?R(n,x>>1):n

Versione iterativa:

F=n=>{for(x=3;x%4>2?x=++n:x>>=1;);return n}

È molto semplice, basta usare il tasto destro per trovare una sequenza di 11. Quando la trovo, passa al numero successivo. La versione ricorsiva è direttamente derivata da quella iterativa.

Ungolfed e più ovvio. Per giocare a golf, la parte più difficile è l'unione dei circuiti interno ed esterno (dovendo iniziare da x a 3 all'inizio)

F = n=>{
  do {
    ++n; // next number
    for(x = n; x != 0; x >>= 1) {
      // loop to find 11 in any position
      if ((x & 3) == 3) { // least 2 bits == 11
        break;
      }
    }
  } while (x != 0) // if 11 was found,early exit from inner loop and x != 0
  return n
}

Python 2, 37 byte

f=input()+1
while f&2*f:f+=1
print f

Usata la logica x & 2*x == 0per 1 numero sparso.
Grazie a @Nick e @CarpetPython.

JavaScript, 75 66 62 byte

Grazie a Martin Büttner per aver salvato 9 byte e Pietu1998 per 4 byte!

function n(a){for(a++;/11/.test(a.toString(2));a++);return a;}

Come funziona: esegue un forciclo a partire da a + 1quando il numero corrente non è 1-sparse e, in tal caso, il ciclo viene interrotto e restituisce il numero corrente. Per verificare se un numero è 1-sparse, lo converte in binario e controlla se non contiene 11.

Codice non golfato:

function nextOneSparseNumber(num) {
    for (num++; /11/.test(num.toString(2)); num++);
    return num;
}

Julia, 40 byte

n->(while contains(bin(n+=1),"11")end;n)

Ciò crea una funzione anonima che accetta come input un singolo intero e restituisce il numero intero 1-sparse successivo più alto. Per chiamarlo, dagli un nome, ad esf=n->... , e fallo f(12).

Ungolfed + spiegazione:

function f(n)

    # While the string representation of n+1 in binary contains "11",
    # increment n. Once it doesn't, we've got the answer!

    while contains(bin(n += 1), "11")
    end

    return(n)
end

Esempi:

julia> f(12)
16

julia> f(16)
20

Suggerimenti e / o domande sono i benvenuti come sempre!

> <> (Pesce) , 31 + 3 = 34 byte

1+:>:  4%:3(?v~~
;n~^?-1:,2-%2<

Uso:

>python fish.py onesparse.fish -v 12
16

3 byte aggiunti per il -vflag.

JavaScript (ECMAScript 6), 40

Per ricorsione:

g=x=>/11/.test((++x).toString(2))?g(x):x

JavaScript, 56

Lo stesso senza funzioni freccia.

function f(x){return/11/.test((++x).toString(2))?f(x):x}

Scala, 65 byte

(n:Int)=>{var m=n+1;while(m.toBinaryString.contains("11"))m+=1;m}

(se è richiesta una funzione con nome, la soluzione sarà 69 byte)

Python, 39 33 byte

Provalo qui: http://repl.it/gpu/2

In forma lambda (grazie a xnor per il golf):

f=lambda x:1+x&x/2and f(x+1)or-~x

La sintassi della funzione standard si è rivelata più breve di una lambda per una volta!

def f(x):x+=1;return x*(x&x*2<1)or f(x)

Java, 33 byte.

Usa il metodo in questa risposta

n->{for(;(n++&2*n)>0;);return n;}

TIO

Ruby, 44

->(i){loop{i+=1;break if i.to_s(2)!~/11/};i}

Piuttosto semplice. Un lambda con un ciclo infinito e una regexp per testare la rappresentazione binaria. Vorrei che loopcedessi e numero di indice.

Matlab ( 77 74 byte)

m=input('');for N=m+1:2*m
if ~any(regexp(dec2bin(N),'11'))
break
end
end
N

Gli appunti:

• Basta numeri di test m+1a 2*m, dove mè l'ingresso.
• ~any(x)è truese xcontiene tutti gli zeri o se xè vuoto

C (32 byte)

f(int x){return 2*++x&x?f(x):x;}

Implementazione ricorsiva dello stesso algoritmo di tante altre risposte.

Perl, 16 byte

Combinando le x&2*xvarie risposte (penso che Nick sia il primo) con le redo rese di nutki :

perl -pe'++$_&2*$_&&redo'

Testato su Fragola 5.26.

Japt, 8 byte

_&ZÑ}fUÄ

Eseguilo online.

Gelatina , 7 byte

‘&Ḥ¬Ɗ1#

Un programma completo che accetta un unico numero intero non negativo che stampa un numero intero positivo (come collegamento monadico produce un elenco contenente un singolo numero intero positivo).

Provalo online!

Come?

Iniziando da v=n+1e aumentando, raddoppiare vper spostare ogni bit verso l'alto di un posto e bit-saggio AND con ve quindi eseguire NOT logico per testare se vè 1-sparse fino a quando non viene trovato un tale numero.

‘&Ḥ¬Ɗ1# - Main Link: n   e.g. 12
‘       - increment           13
     1# - 1-find (start with that as v and increment until 1 match is found) using:
    Ɗ   -   last three links as a dyad:
  Ḥ     -   double v
 &      -   (v) bit-wise AND (with that)
   ¬    -   logical NOT (0->1 else 1)
        - implicit print (a single item list prints as just the item would)

Stax , 5 byte

╦>ù╤x

Esegui ed esegui il debug

Funziona usando questa procedura. L'input inizia in cima allo stack.

• Incrementa e copia due volte.
• Dimezza la parte superiore della pila.
• Bitwise e primi due elementi nello stack.
• Se il risultato è veritiero (diverso da zero), ripetere l'intero programma.