Nota, quando dico "negare", intendo sostituire tutti quelli con zero (cioè una negazione bit a bit)

La sequenza Mar-Morse va come 01101001

Il modo in cui lo generi è:

Inizia prendendo 0. Annulla ciò che è rimasto e aggiungilo alla fine.

Quindi prendi 0. Negalo e aggiungilo alla fine -01

Quindi prendilo e negalo e aggiungilo alla fine - 0110

E così via.

Un'altra proprietà interessante di ciò è che la distanza tra gli zeri crea una stringa "irrazionale" e non ripetitiva.

Così:

0110100110010110
|__|_||__||_|__|
 2  1 0 2 01 2          <------------Print this!

Puoi scrivere un programma che, quando immesso n, produrrà le prime n cifre della stringa da stampare?

Questo è il golf del codice, quindi vince il numero più breve di byte!

Gelatina, 9 byte

;¬$‘¡TI’ḣ

Provalo online!

Come funziona

;¬$‘¡TI’ḣ  Main link. Argument: n

  $        Create a monadic chain that does the following to argument A (list).
 ¬         Negate all items of A.
;          Concatenate A with the result.
   ‘¡      Execute that chain n + 1 times, with initial argument n.
     T     Get all indices of truthy elements (n or 1).
      I    Compute the differences of successive, truthy indices.
       ’   Subtract 1 from each difference.
        ḣ  Keep the first n results.

Python 3 2, 104 92 88 84 byte

Questa è una soluzione piuttosto rudimentale basata sulla costruzione da zero di una sequenza tue-morse ternaria. Questa sequenza è identica a quella richiesta, anche se qualcun altro dovrà scrivere una spiegazione più approfondita del perché. Ad ogni modo, questa sequenza è solo una banale modifica di questa, A036580 .

Modifica: ha cambiato il ciclo for in una comprensione della lista, cambiato da una funzione a un programma e ha cambiato tutto in Python 2. Grazie a Dennis per l'aiuto del golf.

n=input()
s="2"
while len(s)<n:s="".join(`[1,20,210][int(i)]`for i in s)
print s[:n]

Julia, 56 50 byte

n->(m=1;[m=[m;1-m]for _=0:n];diff(find(m))[1:n]-1)

Questa è una funzione anonima che accetta un numero intero e restituisce un array di numeri interi. Per chiamarlo, assegnarlo a una variabile.

Generiamo la sequenza Thue-Morse bit scambiati iniziando con un numero intero m = 1, poi aggiungiamo 1-ma mcome array n+1volte, dove nè l'ingresso. Questo genera più termini di quelli di cui abbiamo bisogno. Individuiamo quindi quelli usando find(m), otteniamo la differenza tra valori consecutivi usando diffe sottraggiamo 1 elementally. Prendere i primi ntermini dell'array risultante ci dà ciò che vogliamo.

Salvato 6 byte e risolto un problema grazie a Dennis!

PowerShell, 102 byte

filter x($a){2*$a+([convert]::toString($a,2)-replace0).Length%2}
0..($args[0]-1)|%{(x($_+1))-(x $_)-1}

Un po 'di un modo diverso di calcolare. PowerShell non ha un modo semplice per "ottenere tutti gli indici in questo array in cui il valore di quell'indice è uguale a questo e così ", quindi dobbiamo essere leggermente creativi.

Qui stiamo usando A001969 , i "numeri con un numero pari di 1s nella loro espansione binaria", che coincidono in modo completamente casuale con gli indici degli 0 nella sequenza Thue-Morse. ;-)

Il filtercalcola quel numero. Ad esempio, x 4darebbe 9. Quindi eseguiamo semplicemente il ciclo dal 0nostro input $args[0], sottraendo 1perché siamo indicizzati a zero e ogni iterazione del loop stampa la differenza tra il numero successivo e il numero corrente. L'output viene aggiunto alla pipeline e implicitamente output con newline.

Esempio

PS C:\Tools\Scripts\golfing> .\print-the-difference-in-the-thue-morse.ps1 6
2
1
0
2
0
1

Haskell, 42 byte

l=2:(([[0..2],[0,2],[1]]!!)=<<l)
(`take`l)

Esempio di utilizzo: (`take`l) 7-> [2,1,0,2,0,1,2].

È un'implementazione di a036585_listda A036585 spostata a 0, 1e 2. Golf: concat (map f l)è f =<< led f 0=[0,1,2]; f 1=[0,2]; f 2=[1]è ([[0..2],[0,2],[1]]!!).

Nota: lè la sequenza infinita. Sono necessari 10 byte o circa il 25% per implementare la funzione take-first n-elements.

Mathematica, 79 68 70 byte

(Differences[Join@@Position[Nest[#~Join~(1-#)&,{0},#+2],0]]-1)[[;;#]]&

MATL , 14 11 byte

Q:qB!Xs2\dQ

Provalo online!

Come sottolineato da @TimmyD nella sua risposta , la sequenza desiderata è data dalle differenze consecutive di A001969 . Quest'ultimo può a sua volta essere ottenuto come la sequenza di martedì e martedì 2 + n . Pertanto la sequenza desiderata è data da (differenze consecutive della sequenza Gio-Morse) più una .

D'altra parte, la sequenza Thue-Morse può essere ottenuta come il numero di quelli nella rappresentazione binaria di n , a partire da n = 0.

Q:q    % take input n implicitly and generate row vector [0,1,...,n]
B!     % 2D array where columns are the binary representations of those numbers
Xs     % sum of each column. Gives a row vector of n+1 elements
2\     % parity of each sum
d      % consecutive differences. Gives a row vector of n elements
Q      % increase by 1. Display implicitly

05AB1E , 14 13 byte

Codice:

ÎFDSÈJJ}¥1+¹£

Spiegazione:

Î              # Push 0 and input
 F     }       # Do the following n times
  DS           # Duplicate and split
    È          # Check if even
     JJ        # Join the list then join the stack
        ¥1+    # Compute the differences and add 1
           ¹£  # Return the [0:input] element

Provalo online!

Python, 69 byte

t=lambda n:n and n%2^t(n/2)
lambda n:[1+t(i+1)-t(i)for i in range(n)]

Il itermine di questa sequenza è 1+t(i+1)-t(i), dove si ttrova la funzione Gio-Morse. Il codice lo implementa in modo ricorsivo, che è più breve di

t=lambda n:bin(n).count('1')%2

Mathematica, 65 byte

SubstitutionSystem[{"0"->"012","1"->"02","2"->"1"},"0",#][[;;#]]&

Batte l'altra mia risposta, ma non batte la versione golfata molto piccante . Ora normalmente inserisco il mio codice tra virgolette, quindi lo estraggo perché Mathematica ama aggiungere spazi al tuo codice (che non fa nulla) ma non si scherza mai con le stringhe, ma non funziona per il codice che ha le virgolette ...

Qualunque cosa, sto solo usando la magia integrata per questo. L'output è una stringa.

Mathematica, 58 byte

Differences[Nest[Join[#,1-#]&,{0},#]~Position~0][[;;#]]-1&

Perl, 45 + 2 = 47 byte

$_=2;s/./(1,20,210)[$&]/ge until/.{@F}/;say$&

Richiede il flag -pe -a:

$ perl -pa morse-seq.pl <<< 22                                                                            
2102012101202102012021

Risposta Port of @ Sherlock9

Risparmiato 9 byte grazie a Ton

JavaScript (ES6), 73 67 byte

f=(n,s="2")=>s[n]?s.slice(0,n):f(n,s.replace(/./g,c=>[1,20,210][c]))

La risposta di Port of @ Sherlock9.

modifica: 6 byte salvati grazie a @WashingtonGuedes.

CJam (19 byte)

1ri){2b:^}%2ew::-f-

Demo online

Questo utilizza l'approccio per incrementare le successive differenze tra gli elementi della sequenza Gio-Morse.

Il mio approccio più breve utilizzando le regole di riscrittura è di 21 byte:

ri_2a{{_*5*)3b~}%}@*<

(Attenzione: lento). Questo codifica le regole di riscrittura

0  ->  1
1  ->  20
2  ->  210

come

x -> (5*x*x + 1) in base 3

Rubino, 57 byte

Una porta della risposta Python di xnor. I cambiamenti si trovano principalmente nell'affermazione ternaria tal posto di quella anddovuta alla 0verità in Ruby e all'uso (1..n).mape 1+t[i]-t[i-1]al salvataggio dei byte anziché all'importazione diretta della comprensione dell'elenco.

t=->n{n<1?n:n%2^t[n/2]}
->n{(1..n).map{|i|1+t[i]-t[i-1]}}

Mathematica ( quasi non verbale), 107 110 byte

({0}//.{n__/;+n<2#}:>{n,{n}/.x_:>(1-x)/._[x__]:>x}//.{a___,0,s:1...,0,b___}:>{a,+s/.(0->o),0,b}/.o->0)[[;;#]]&

La sequenza viene generata applicando ripetutamente una regola di sostituzione. Un'altra regola lo trasforma nell'output desiderato. Se ci sono abbastanza persone interessate, ti spiego in dettaglio.

versione non alfanumerica

({$'-$'}//.{$__/;+$/#
<($'-$')!+($'-$')!}:>
{$,{$}/.$$_:>(($'-$')
!-$$)/.{$$__}:>$$}//.
{$___,$'-$',$$:($'-$'
)!...,$'-$',$$$___}:>
{$,+$$/.($'-$'->$$$$)
,$'-$',$$$}/.$$$$->$'
-$')[[;;#]]

come suggerito da CatsAreFluffy.