La sequenza Baum-Sweet (A086747 con una svolta)

Prendi un numero intero positivo ne stampa i numeri interi da 1 a n per i quali la sequenza Baum-Sweet ritorna vera. La sequenza Baum-Sweet dovrebbe restituire falsi se la rappresentazione binaria del numero contiene un numero dispari di zeri consecutivi in ​​qualsiasi punto del numero, e in verità altrimenti. Per ulteriori informazioni, fare clic sul collegamento. Ecco un paio di esempi:

1 -> 1 -> Truthy
2 -> 10 -> Falsy
3 -> 11 -> Truthy
4 -> 100 -> Truthy (Even run of zeros)

Ecco un esempio dato n=32

Step 1: La sequenza Baum-Sweet visualizzata per n=32

1               1 (1)
1 0             0 (2)
11              1 (3)
1 00            1 (4)
1 0 1           0 (5)
11 0            0 (6)
111             1 (7)
1 000           0 (8)
1 00 1          1 (9)
1 0 1 0         0 (10)
1 0 11          0 (11)
11 00           1 (12)
11 0 1          0 (13)
111 0           0 (14)
1111            1 (15)
1 0000          1 (16)
1 000 1         0 (17)
1 00 1 0        0 (18)
1 00 11         1 (19)
1 0 1 00        0 (20)
1 0 1 0 1       0 (21)
1 0 11 0        0 (22)
1 0 111         0 (23)
11 000          0 (24)
11 00 1         1 (25)
11 0 1 0        0 (26)
11 0 11         0 (27)
111 00          1 (28)
111 0 1         0 (29)
1111 0          0 (30)
11111           1 (31)
1 00000         0 (32)

Quindi, dopo aver calcolato la sequenza Baum-Sweet per n, prendi i numeri che erano veri per la sequenza e collezionali per il risultato finale. Perché n=32avremmo:

[1, 3, 4, 7, 9, 12, 15, 16, 19, 25, 28, 31]

Come la risposta finale.

Questo è code-golf , vince il conteggio dei byte più corto.

05AB1E , 10 9 byte

Salvato un byte grazie ad Adnan

ƒNb00¡SP–

Provalo online!

Spiegazione

ƒ          # for N in [0 ... input]
 Nb        # convert N to binary
   00¡     # split at "00"
      S    # convert to list of digits
       P   # product of list
        –  # if 1, print N

JavaScript (ES6), 70 68 63 byte

g=n=>n?g(n-1).concat(/0/.test(n.toString(2).split`00`)?[]:n):[]

console.log(g(1000).join(", "))

Soluzione ricorsiva leggermente più interessante:

n=>[...Array(n+1).keys()].filter(f=n=>n<2?n:n%4?n&f(n>>1):f(‌​n/4))

67 byte grazie a @Neil.

g è la funzione da chiamare.

Python 2, 62 byte

g=lambda n:n*[0]and g(n-1)+[n]['0'in`bin(n)[1:].split('00')`:]

Verifica la presenza di sequenze dispari di 1 nella rappresentazione binaria suddividendola 00e verificando se rimangono zero nella rappresentazione di stringa dell'elenco risultante. In modo fastidioso, iniziano i numeri binari 0b, che ha uno zero che deve essere rimosso per evitare un falso positivo.

L'enumerazione viene eseguita ricorrendo verso il basso.

bash, 58, 46 byte

Modifiche:

• Sostituito bc con dc (Thx @Digital Trauma!)
• Inizia con 1;

golfed

seq $1|sed 'h;s/.*/dc -e2o&p/e;s/00//g;/0/d;x'

Test

>./baum 32
1 
3
4
7 
9
12
15
16
19
25
28
31

spiegato

conchiglia

seq $1 #generate a sequence of integers from 1 to N, one per line
|sed   #process with sed

sed

h                #Save input line to the hold space
s/.*/dc -e2o&p/e #Convert input to binary, with dc
s/00//g          #Remove all successive pairs of 0-es
/0/d             #If there are still some zeroes left
                 #(i.e. there was at least one odd sequence of them)
                 #drop the line, proceed to the next one
x                #Otherwise, exchange the contents of the hold 
                 #and pattern spaces and (implicitly) print

Provalo online!

Lotto, 143 byte

@for /l %%i in (1,1,%1)do @call:c %%i
@exit/b
:c
@set/ai=%1
:l
@if %i%==1 echo %1&exit/b
@set/ar=%i%%%4,i/=4-r%%2*2
@if %r% neq 2 goto l

Perl 6 , 40 byte

{grep {.base(2)!~~/10[00]*[1|$]/},1..$_}

Provalo

{
  grep            # find all of them
  {
    .base(2)      # where the binary representation
    !~~           # does not match
    /
      10          # ｢10｣
      [ 00 ]*     # followed by an even number of ｢0｣s
      [ 1 | $ ]   # either at end or before a ｢1｣
    /
  }, 1 .. $_      # from one to the input
}

( []sono usati per raggruppamenti non acquisiti, con <[]>usati per classi di caratteri)

PowerShell , 79 61 byte

1..$args[0]|?{0-notin([convert]::ToString($_,2)-split'1|00')}

Provalo online!

Ho avuto l'ispirazione stamattina per cambiare il modo -splitin cui eseguo l' operazione, quindi vedo che è simile al modo in cui è costruita la risposta di xnor , quindi, immagino che le grandi menti la pensino allo stesso modo?

Passiamo da 1un input all'altro $args[0]e utilizziamo un Where-Objectoperatore per estrarre i numeri appropriati |?{...}. La clausola è un semplice valore booleano: stiamo assicurando che questo 0sia -notinil risultato di (...).

All'interno delle parentesi, abbiamo [convert]::il numero corrente $_ ToStringcon la base 2(cioè, lo trasformiamo in una stringa binaria). Abbiamo quindi -splitla stringa sulla regex 1|00: questa è una corrispondenza avida e si traduce in una serie di stringhe (ad esempio, 100010si trasformerebbe in '','','0','','0'e così via).

Pertanto, se ogni 0sequenza di s nella stringa binaria è pari (nel senso che il regex li ha suddivisi in stringhe vuote), allora 0sarà -notinil risultato, quindi la Whereclausola è vera e il numero è selezionato. Quei numeri vengono lasciati in cantiere e l'output è implicito.

Python 2 , 67 47 byte

f=lambda n,k=1:n/k*[1]and[k]+f(n,k-~k)+f(n,4*k)

Grazie a @xnor per giocare a golf con 20 (!) Byte!

Restituisce un elenco non ordinato. È abbastanza efficiente: l'input 100.000 richiede circa 40 ms su TIO.

Provalo online!

Mathematica, 59 byte

Select[Range@#,!Or@@OddQ/@Tr/@Split[1-#~IntegerDigits~2]&]&

Mathematica risposta numero 4 ...

MATL , 12 11 byte

:"@BY'og)?@

Provalo online!

Spiegazione

Per rilevare se un numero è valido, questo viene convertito in binario, applica la codifica della lunghezza di esecuzione, mantiene solo le esecuzioni di lunghezza dispari e verifica se non sussiste alcuna esecuzione di zeri.

:       % Take input n implicitly. Push range [1 2 ... n]
"       % For each k in [1 2 ... n]
  @     %   Push k
  B     %   Convert to binary
  Y'    %   Run-length encoding. Pushes array of values and array of run-lengths
  o     %   Parity. Gives array that contains 0 for even lengths, 1 for odd
  g)    %   Convert to logical and use index into the array of values
  ?     %   If the result does not contain zeros
    @   %     Push k
        %   End
        % End
        % Implicitly display stack 

R, 75 byte

for(i in 1:scan()){x=rle(miscFuncs::bin(i));if(!any(x$l%%2&!x$v))cat(i,"")}

Legge l'input da stdin e utilizza la binfunzione dal miscFuncspacchetto per convertire da decimale a vettore binario. Di conseguenza esegue la codifica run-length per verificare che valori == 0e lunghezze siano dispari.

Stacked , 69 byte

Provalo qui!

:>1+[bits{e.b:e b 0#=}chunkby[0 has]filter$sizemap 2%0 eq all]"filter

Oppure, non competitivo a 67 byte:

:>1+[bits{e.b:e b 0#=}chunkby[0 has]filter$sizemap even all]"filter

E, ancora più non competitivo a 49 byte:

:>1+[bits rle{k:k 0=}filter values even all]fkeep

Tutti accettano input come TOS e lasciano output su TOS.

Spiegazione

:>1+[...]"filter   input: n
:>                 range from [0, n)
  1+               range from [1, n]
    [...]          a function
         "filter   apply to each cell and filter

La funzione:

bits{e.b:e b 0#=}chunkby[0 has]filter$sizemap 2%0 eq all  input: c
bits                                                      convert c to binary
    {e.b:e b 0#=}chunkby                                  split into chunks of contiguous 0s
                        [0 has]filter                     take only chunks with 0s
                                     $sizemap             map each chunk to its size
                                              2%          vectorized modulus 2
                                                0 eq      vectorized equality with 0
                                                     all  all of them are of even lengths

Spiegazione di non concorrenza:

È lo stesso di sopra, con alcune differenze chiave:

:>1+[bits rle{k:k 0=}filter values even all]fkeep   input: y
          rle                                       run length encode y
             {k:k 0=}filter                         keep keys that = 0
                            values                  get those values
                                            fkeep   like `filter`, but is implemented with
                                                    taking `f` as a boolean mask

Befunge, 84 51 49 byte

Dopo un po 'di sperimentazione, mi sono reso conto che avrei potuto fare un po' meglio della mia soluzione originale usando una tecnica simile alla risposta Batch che Neil ha inventato.

<v::\<&1
:_v#:/+2*2!%2:_v#-2%4
:$<@_v#!:-1\+1$<:.

Provalo online!

Come per la mia soluzione originale, ci sono due loop: il loop esterno che scorre sui numeri che vogliamo testare e un loop interno che verifica la sequenza di bit per ciascun numero. Il modo in cui funziona il test è esaminando due bit alla volta (modulo 4 del valore corrente). Se è uguale a 2, abbiamo una sequenza dispari di zeri e possiamo interrompere il ciclo interno e passare al numero successivo.

Se il modulo 4 non è uguale a 2, dobbiamo continuare a testare i bit rimanenti, quindi spostiamo in alto i bit che sono già stati testati. Questo viene fatto dividendo il valore, chiamiamolo n , per 2+2*!(n%2). Ciò significa che se il primo bit era 1, dividiamo per 2 (rilasciando quel 1 bit), ma se fosse uno 0, dividiamo per 4, quindi lasceremo sempre cadere le coppie di zeri.

Se alla fine arriviamo a zero, ciò significa che non c'erano sequenze dispari di zero bit, quindi scriviamo il numero.

Visual Basic (.net 4.5) 163 byte

Prima di tutto rispondo qui, quindi sono sicuro di aver rovinato qualcosa. Fammi sapere e riparerò. Sono ammessi anche i lambda di Visual Basic?

Grazie a MamaFunRoll per la rimozione dell'idea di zero consecutivi

Dim R=Sub(m)System.Console.WriteLine(String.Join(",",System.Linq.Enumerable.Range(1, m).Where(Function(s) Not Convert.ToString(s,2).Replace("00","").Contains(0))))

R (32) uscite

1,3,4,7,9,12,15,16,19,25,28,31

Java, 144 130 128 byte

Non è così facile come penso, ma ho pensato che sarebbe stata una soluzione carina usare un Regex, nonostante non ne avessi mai usato uno.

golfed:

static String a(int n){String s="";for(Integer i=0;i++<n;)if(i.toString(i,2).replaceAll("00|1","").isEmpty())s+=i+" ";return s;}

Ungolfed:

static String a(int n){
    String s="";                      //Cheaper than using a list/array
    for(Integer i=0;i++<n;)           //Loop n times
        if(i.toString(i,2)            //Convert int to base 2 string
                .replaceAll("00|1","")//Find and remove ones and consecutive zeroes
                .isEmpty())           //If any chars remain, i is truthy
            s+=i+" ";                 //Append i to the storage string
    return s;                         //Return all values
}

Modifica: Sono stato in grado di salvare 14 byte creando il regex 00 | 1 invece di 00 e rimuovendo ".replace (" 1 "," ")" tra ReplaceAll e isEmpty!

Modifica 2: Sono stato in grado di salvare 2 byte rendendo i numeri interi e facendo riferimento a Integer.toString con i.toString.

Clojure, 103 byte

Non penso che questo sia il modo più breve ...

#(remove(fn[v]((set(map(fn[s](mod(count s)2))(re-seq #"0+"(Integer/toString v 2))))1))(range 1(inc %)))

Usa re-seqper trovare zeri consecutivi, mappa le loro lunghezze modulo-2 su a set, li scarta se 1viene trovato un numero dal set.

Meraviglia , 38 byte

@(!>@=1len iO0Rstr#["00"]bn#0)rng1+1#0

Uso:

(@(!>@=1len iO0Rstr#["00"]bn#0)rng1+1#0) 32

Spiegazione

Più leggibile:

@(
  fltr@
    = 1 
      len 
        iO 0 
          Rstr #["00"] 
            bn #0
) rng 1 +1 #0

rng 1 +1 #0: Intervallo da 1 a input.

fltr@ ...: Consente di filtrare l'intervallo con il predicato seguente.

bn #0: Converte l'elemento corrente in binario. (Questo avrà un vantaggio 0b).

Rstr #["00"]: Elimina ricorsivamente qualsiasi occorrenza di 00nella stringa.

len iO 0: Conta le quantità di 0s nella stringa.

=1: Controlla se l'importo è uguale a 1. Se l'unica 0rimasta nella stringa dopo la potatura è in testa 0b, allora questo restituisce vero; in caso contrario, questo restituisce false.

Rubino, 78 69 68 byte

->n{(1..n).select{|m|m.to_s(s=2).split(?1).map{|i|s|=i.size};s&1<1}}

Versioni precedenti:

->n{(1..n).select{|m|m.to_s(2).split(?1).select{|i|i.size%2>0}[0].!}}
->n{(1..n).select{|m|b=z=0;(m.to_s(2)+?1).each_char{|i|z+=i>?0?b|=z:1};b&1<1}}

Mathematica, 81 byte

Select[Range@#,FreeQ[Union@#+Mod[Length@#,2,1]&/@Split[#~IntegerDigits~2],{1}]&]&

Calcola, per ogni sequenza di cifre consecutive in un numero, {la cifra comune in quella sequenza più (1 se la lunghezza è dispari, 2 se la lunghezza è pari)}; se una delle risposte è {1}, il numero non è nella sequenza.

Mathematica, 75 byte

Select[Range@#,And@@EvenQ/@Length/@Cases[Split[#~IntegerDigits~2],{0..}]&]&

#~IntegerDigits~2calcola l'elenco delle cifre binarie dell'input #. Splitche elenca in serie di elementi identici, prende Casesquella corrispondenza {0..}, ne prende Lengthciascuna, prende EvenQle lunghezze e quindi restituisce Andi risultati.

Python 3, 86 82 byte

Giocare a golf in corso ...

lambda n:[x for x in range(1,n+1)if 1-any(i%2for i in map(len,bin(x).split('1')))]

Golfato di 4 byte cambiando bin(x)[2:]in solo bin(x)- questo lascia 0ball'inizio della stringa, ma mi sono reso conto che in realtà non influisce sui calcoli :)

Python, 142 byte

Questo è principalmente solo per praticare il golf con il mio Python.

def o(n):
 r=0
 for i in bin(n)[2:]:
  if i=='1':
   if r&1:return 0
   r=0
  else:r+=1
 return ~r&1
lambda n:[i for i in range(1,n+1)if o(i)]

Gelatina , 10 byte

2ṗx"`ḂḄf@R

Terribilmente inefficiente. Provalo online!

Rubino, 54 53 48 byte

->n{(1..n).reject{|x|x.to_s(2)=~/10(00)*(1|$)/}}

Non pensavo che la regex per questo sarebbe stata così semplice.

modifica 1: passa a rifiutare per eliminare la negazione per -1.

modifica 2: passato matcha =~-5.

C # 159 157 155 byte

Risparmiato 2 x due byte grazie a TuukkaX.

Nota: stampa gli ints in ordine inverso.

void B(int n){var b=Convert.ToString(n,2);int c=0,i=0;for(;i<b.Length;){if(b[i++]<49)c++;else if(c%2>0)break;}if(c%2<1)Console.WriteLine(n);if(n>1)B(--n);}

Spiegazione:

void B(int n)
{
    // convert our int to a binary string
    var b = Convert.ToString(n, 2);

    // set our '0' counter 'c' and our indexer 'i' 
    int c = 0, i = 0;

    // loop over the binary string, without initialisation and afterthought
    for (; i < b.Length;)
    {
        // check for '0' (48 ASCII) and increment i. increment c if true
        if (b[i++] < 49)
            c++;

        // otherwise check if c is odd, and break if it is
        else if (c%2 > 0)
            break;
    }

    // print the int if c is even
    if (c%2 < 1)
        Console.WriteLine(n);

    // recursively call B again with the next number
    if (n > 1)
        B(--n);
}

Mathematica, 69 byte

Select[Range@#,FreeQ[#~IntegerDigits~2//.{x___,0,0,y___}:>{x,y},0]&]&

La stessa lunghezza:

Select[Range@#,#~IntegerString~2~StringDelete~"00"~StringFreeQ~"0"&]&

Rubino, 53 byte

->n{(1..n).each{|n|p n if n.to_s(2).count(?0).even?}}

Gelatina, 15 13 10 byte

salvato due byte dopo aver visto altre risposte, altri 3 byte grazie a Dennis

Bœṣ0,0Ȧµ€T

Spiegazione

Bœṣ0,0Ȧµ€T -Helper link: argument K (integer): ex. 24
B          -Convert K to a list of its binary digits: 24 -> [1,1,0,0,0]
   0,0     -Create a list of two 0's: [0,0]
 œṣ        -Split the binary digits on instances of the sublist: [1,1,0,0,0]-> [[1,1],[0]]
      Ȧ    -Any and All: Check if our list has any falsy values or is empty
       µ   -Take all our previous atoms and wrap them into one monad.
        €  -Map this new monad over a list. Since our input is an integer, this implicitly maps it over the range [1..N] (Like the 'R' atom)
         T -Get the indices of all truthy values (1's)