Aufeinanderfolgende 1-Bits werden inkrementiert

36

Gegeben ein Muster (String- oder Array-Format) von Bits: [0,1,1,1,0,1,1,0,0,0,1,1,1,1,1,1]

Die Aufgabe besteht darin, eine beliebige Anzahl aufeinanderfolgender 1-Bits durch eine aufsteigende Zahlenfolge zu ersetzen, die bei 1 beginnt.

Eingang

  • Muster (kann als String oder Array empfangen werden) Beispiel:
    • Zeichenfolge: 1001011010110101001
    • Array: [1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1]

Ausgabe

  • Aufsteigende Zahlenfolge (kann als Zeichenfolge oder Array zurückgegeben werden) Beispiel:
    • Zeichenfolge: 1 0 0 1 0 1 2 0 1 0 1 2 0 1 0 1 0 0 1
    • Array: [1, 0, 0, 1, 0, 1, 2, 0, 1, 0, 1, 2, 0, 1, 0, 1, 0, 0, 1]

Regeln

  • (gilt nur für Zeichenketten) Die Eingabe enthält keine Leerzeichen zwischen 1und0
  • Eingabe übernehmen length > 0
  • (gilt nur für Zeichenfolgen) Die Ausgabe wird durch ein Leerzeichen getrennt. (Verwenden Sie ein beliebiges anderes Trennzeichen, wenn Sie nicht eine Zahl oder einen Buchstaben aus dem Alphabet benötigen.)

Beispiel: 

Given [0,1,1,1,0,1,1,0,0,0,1,1,1,1,1,1] 
Output [0,1,2,3,0,1,2,0,0,0,1,2,3,4,5,6]

--------------------------------------------------------------------------

Given 0110101111101011011111101011111111     
Output 0 1 2 0 1 0 1 2 3 4 5 0 1 0 1 2 0 1 2 3 4 5 6 0 1 0 1 2 3 4 5 6 7 8

---------------------------------------------------------------------------

Given 11111111111101    
Output 1 2 3 4 5 6 7 8 9 10 11 12 0 1

Gewinnkriterien: Codegolf

code-golf  sequence 
— Luis Felipe De Jesus Munoz
quelle

Antworten:

19

05AB1E , 4 Bytes

γ€ƶ˜

Probieren Sie es online! oder als Testanzug

Erläuterung

γ      # split input into groups of consecutive equal elements
 €ƶ    # multiply each number in each sublist by its 1-based index in the sublist
   ˜   # flatten
— Emigna
quelle
1
Oof, besser als meins. Daran hätte ich nie gedacht.
— Magic Octopus Urn
3
Ich bin nicht 100% vertraut mit den Codegolf-Byte-Zählregeln (und Googeln hat nur diesen Beitrag gefunden, der nicht zu einem Abschluss gekommen ist). Während Ihre Antwort aus 4 Zeichen besteht, sollten es nicht mindestens 8 Bytes (z. B. utf-16-ohne Stückliste sein 03 B3 20 AC 01 B6 02 DC) oder 9 Bytes (utf-8:) CE B3 E2 82 AC C6 B6 CB 9Coder 10 Bytes (z. B. UTF-16 einschließlich der 2-Byte-Stückliste) sein. in irgendeiner Nicht-Spielzeug-Kodierung? (Ja, man könnte eine 8-Bit-Codierung für Spielzeuge
— erstellen
6
@drjimbob Ja, gute Frage. Der Code kann mithilfe der Codepage 05AB1E in eine Binärdatei konvertiert werden . Beispielsweise γ€ƶ˜würde dargestellt werden als 04 80 8F 98. Die Codepage dient in erster Linie dazu, das Schreiben von Code zu vereinfachen. Um diese 4-Byte-Datei auszuführen, müssen Sie den Interpreter mit dem --osabieFlag ausführen .
— Adnan
18

Haskell , 15 Bytes

scanl1$(*).succ

Probieren Sie es online!

Erklärung / Ungolfed

scanl1 iteriert von links über eine Liste mit einer Funktion, die das letzte Ergebnis und das aktuelle Element verwendet, um eine neue Liste mit den Ergebnissen zu erstellen, wobei leere Listen und Singletons "unverändert" bleiben.

(*).succ ist das Äquivalent von \x y-> (x+1)*y

Die Verwendung dieser Funktion zusammen mit funktioniert scanl1nur, weil die aufsteigenden Sequenzen ( 1,2,3, .. ) mit 1 beginnen und entweder kein vorhergehendes Element haben (in diesem Fall ist es das erste Element in der Liste, das nicht "modifiziert" wird). oder sie haben eine führende 0 .

— ბიმო
quelle
14

Schale , 5 4 3 Bytes

ṁ∫g

Probieren Sie es online!

Erläuterung

ṁ∫g  -- full function, example input: [1,1,1,0,1]
  g  -- group: [[1,1],[0],[1]]
ṁ    -- map the following and concatenate result (example with [1,1,1])
 ∫   -- | cumulative sum: [1,2,3]
     -- : [1,2,3,0,1]

Verlauf bearbeiten

-1 Byte bei Verwendung von scanl1overzipWith

-1 Byte durch Portierung von Dennis ' Lösung

— ბიმო
quelle
11

JavaScript (ES6), 22 Byte

Übernimmt die Eingabe als Array.

a=>a.map(s=n=>s=n*-~s)

Probieren Sie es online!

Die kürzeren a=>a.map(n=>a=n*-~a)(20 Bytes) würden leider fehlschlagen, [1]da Singleton-Arrays zu der Ganzzahl gezwungen werden, die sie halten.

— Arnauld
quelle
6

Gelee , 4 Bytes

‘×¥\

Probieren Sie es online!

‘×¥\
   \   Accumulate the input with:
  ¥   The dyad
‘      Increment the left element
 ×    Multiply by the second element (1 or 0)
       The result always begins with the first element unchanged
— dylnan
quelle
6

K (oK) , 11 8 Bytes

Lösung:

{y*1+x}\

Probieren Sie es online!

Erläuterung:

Durchlaufen Sie die Liste. Inkrement-Akku, multiplizieren mit aktuellem Artikel (setzt den Akku zurück, wenn der Artikel 0 ist):

{y*1+x}\ / the solution
{     }\ / iterate (\) over lambda function
     x   / accumulator
   1+    / add 1
 y*      / multiply by current item
— Streetster
quelle
5

Gelee , 4 Bytes

ŒgÄF

Probieren Sie es online!

Wie es funktioniert

ŒgÄF  Main link. Argument: A (bit array)

Œg    Group adjacent, identical bits.
  Ä   Accumulate; take the cumulative sum of each chunk.
   F  Flatten.
— Dennis
quelle
Bei den schnellen Gruppenläufen hatte Erik vorgeschlagen, dass dies drei Bytes sein würden! (Wenn ich verstehe, was es richtig machen würde)
— Dylnan
@dylnan Das Problem ist, dass es schwierig ist, sich für ein solches Verhalten zu entscheiden. :( Deshalb ist das schnelle noch in der Pause.
— Erik der Outgolfer
Für die wichtigsten möglichen Implementierungen kann es mehrere Quick-
— ups geben
5

RAD, 8 Bytes

(⊢×1+⊣)⍂

Probieren Sie es online!

Wie?

  • (⊢×1+⊣)Wenn das rechte Argument " 0return" ist , erhöhen Sie 0andernfalls das linke Argument
  • ⍂, LTR-Scan ( (A f B) f Canstelle von A f (B f C)), wenden Sie dies auf das gesamte Array an
— Zacharý
quelle
4

Japt, 7 6 5 Bytes

åÏ*°X

Versuch es

Erläuterung

åÏ        :Cumulatively reduce
   °X     :  Increment the current total (initially 0)
  *       :  Multiply by the current element
— Zottelig
quelle
4

Java 8, 55 48 Bytes

a->{int p=0,i=0;for(int v:a)a[i++]=v<1?p=0:++p;}

Ändert das Eingabe-Array, anstatt ein neues zurückzugeben, um Bytes zu sparen.

-7 Bytes dank @TimSeguine .

Probieren Sie es online aus.

Erläuterung:

a->{             // Method with integer-array parameter and no return-type
  int p=0,       //  Previous integer, starting at 0
      i=0;       //  Index-integer, starting at 0
  for(int v:a)   //  Loop over the values of the input-array:
    a[i++]=v<1?  //   If the current value is 0:
          p=0    //    Reset the previous integer to 0
         :       //   Else:
          ++p;}  //    Increase `p` by 1 first with `++p`
                 //    and set the current item to this new value of `p`
— Kevin Cruijssen
quelle
1
Sie können es bis 48 rasieren:a->{int p=0,i=0;for(int b:a)a[i++]=b<1?p=0:++p;}
— Tim Seguine
@ TimSeguine Danke! Jetzt, wo ich es sehe, kann ich nicht glauben, dass ich selbst nicht darüber nachgedacht habe.
— Kevin Cruijssen
1
Ich konnte p loswerden, aber es ist die gleiche Größe :(a->{int i=0;for(int v:a)a[i]+=v*i++<1?0:a[i-2];}
— Tim Seguine
4

TIS , 68 + 33 = 101 Bytes

Code (68 Bytes):

@0
MOV UP ACC
SUB 47
MOV ACC ANY
@1
ADD 1
JRO UP
SUB ACC
MOV ACC ANY

Layout (33 Bytes):

2 1 CC I0 ASCII - O0 NUMERIC - 32

Probieren Sie es online!

Erläuterung:

|    Input 0    |    Input is given in ASCII (`0` is 48, `1` is 49)
+--------+------+
| Node 0 |      |    This node prepares the input data
+--------+      |
| MOV UP ACC    |    Read in a character
| SUB 47        |    Subtract 47 to map [48, 49] to [1, 2]
| MOV ACC ANY   |    Send the 1 or 2 to the next node
|               |    Implicitly wrap back to top of node
+--------+------+
| Node 1 |      |    This node does the incrementing/printing
+--------+      |
| ADD 1         |    Increment counter (starts at zero)
| JRO UP        |    Get value from above, and jump forward that many lines  (skip next line or not)
| SUB ACC       |    Reset counter to zero (if input was zero)
| MOV ACC ANY   |    Send the counter value downward to be printed
|               |    Implicitly wrap back to top of node
+---------------+
|   Output 0    |    Output is space-delimited numeric values
— Phlarx
quelle
4

Gaia , 5 Bytes

ẋ+⊣¦_

Probieren Sie es online!

Erläuterung

ẋ+⊣¦_     Full program
ẋ         Split into chunks of equal adjacent values.
   ¦_     And for each chunk, flattening the result afterwards...
 +⊣       Reduce it cumulatively on + (addition); aka cumulative sums

Ugh, ich dachte, SE-Code-Schriften wären Monospace ...

— Mr. Xcoder
quelle
Sie sind Monospace ... In der ersten Zeile fehlt ein Leerzeichen.
— Micsthepick
Schau dir die Bearbeitung an. Es ist immer noch falsch ausgerichtet.
— Mr. Xcoder
Sie müssen von einem mobilen Gerät oder etwas suchen - Es sieht für mich gut aus
— micsthepick
@ Micsthepick Ich bin nicht ...
— Mr. Xcoder
4

Perl 6 , 29 24 18 Bytes

-6 Bytes danke an Sean!

*.map:{($+=1)*=$_}

Probieren Sie es online!

Die innere Funktion könnte durch ($+=1)*=*, aber dann würde die anonyme Variable über Funktionsaufrufe hinweg bestehen bleiben. Dies erreichen wir, indem wir es in einen expliziten Codeblock einschließen.

Erläuterung:

*.map:               # Map the array to
      {($+=1)    }   # The anonymous variable incremented
             *=$_    # Multiplied by the element
— Scherzen
quelle
Ich habe die gleichen grundlegenden Ansatz bis zu 16 Byte: *.map(($+=1)*=*). Diese Lösung hat den Vorbehalt, dass die Statusvariable bei $allen Aufrufen der Funktion erhalten bleibt. Wenn also das letzte Element, das an einen Aufruf übergeben wird, und das erste Element, das an den nächsten Aufruf übergeben wird, beide ungleich Null sind, beginnt die Zählung mit der falschen Nummer.
— Sean
@ Sean, ja, ich erinnere mich, dass ich damit gekämpft habe, als ich ursprünglich geantwortet habe. Glücklicherweise habe ich seitdem einen Weg gefunden, das
— Jo King,
Sie können ein weiteres Byte aus klopfen *.map:{...}.
— Sean
3

Pyth , 6 Bytes

m=Z*hZ

Probieren Sie es hier aus!

Wie es funktioniert

m = Z * hZ - Volles Programm. Q = der ausgewertete Eingang.
m - Für jede ganze Zahl d in Q.
 = Z - Weisen Sie die Variable Z (vorinitialisiert auf 0) zu ...
   * hZ - (Z + 1) * d; (d ist am Ende implizit).
— Mr. Xcoder
quelle
3

Wollte eine Antwort mit regulären Ausdrücken bekommen. Es gibt wahrscheinlich eine einfachere Lösung, die ich dem Leser als Übung überlasse.

PowerShell Core , 86 Byte

Filter F{($_-split"(0)(\B|\b)"|?{$_-ne''}|%{$_-replace'(1+)',(1..$_.Length)})-join' '}

Probieren Sie es online!

— Jeff Freeman
quelle
3

QBasic, 60 Bytes

INPUT s$
FOR i=1TO LEN(s$)
b=MID$(s$,i)>="1
v=-b*v-b
?v
NEXT

Nimmt die Eingabe als String; gibt die Ausgabe als durch Zeilenumbrüche getrennte Zahlen aus.

Erläuterung

Wir lesen die Zeichenfolge s$und Schleife ivon 1bis zu ihrer Länge.

MID$(s$,i)Ruft die Teilzeichenfolge vom Zeichen i(1-indiziert) bis zum Ende der Zeichenfolge ab. Wenn dies mit a beginnt 1, ist es lexikografisch >=die Zeichenfolge "1". Wenn es mit einem beginnt 0, wird es nicht sein. So bwird ermittelt, 0ob das Zeichen bei Index isteht 0oder -1ob das Zeichen steht 1.

Als nächstes aktualisieren wir den aktuellen Wert v. Wenn wir nur a lesen 0, wollen wir vwerden 0; ansonsten wollen wir vum eins inkrementieren . Mit anderen Worten v = (-b) * (v+1); Vereinfachung der Mathematik ergibt den kürzeren Ausdruck im Code. Zum Schluss drucken vund loopen wir .

— DLosc
quelle
3

Brain-Flak , 60 Bytes

([]){{}<>(())<>{{}<>({}({}))(<>)}{}([])}{}<>{({}[()]<>)<>}<>

Probieren Sie es online!

Erläuterung:

([]){  For each element in the input
    {}
    <>(())<>  Push a one to the other stack
    { If the element is one,
       {}<>({}({}))(<>)  Add the one to a copy of the previous number in the series
    }{}  Pop the element
([])}  End loop
{}<>   Pop extra zero
{({}[()]<>)<>}<>   And reverse the output stack, subtracting one from each element
— Scherzen
quelle
3

C (gcc), 57 52 51 Bytes

f(a,l,c,i)int*a;{for(c=i=0;i<l;)a[i++]=c=a[i]*-~c;}

Durch die JavaScript-Antwort von Port of Arnauld wird das Array direkt geändert. Probieren Sie es hier online aus .

— OOBalance
quelle
Wäre es nicht genauer zu sagen, dass dies K & R C ist?
— Tim Seguine
Möglicherweise, aber das würde für viele Antworten zutreffen. Ich bin kein Experte, aber es ist durchaus möglich, dass es nicht einmal für K & R C gilt. Die Sprachstandards auf dieser Site sind uns eigentlich egal. Wenn Sie mit gcc K & R C mit moderneren Sachen mischen können, dann ist es zum Golfen ein gültiges C, weil gcc es kompiliert. Siehe auch: codegolf.stackexchange.com/questions/2203/tips-for-golfing-in-c
— OOBalance
Ich habe erst jetzt bei der Suche festgestellt, dass C11 immer noch die alte Syntax der Bezeichnerlistenfunktion unterstützt. Aber dein Punkt gilt trotzdem.
— Tim Seguine
1
Suggestf(a,l,c)int*a;{for(c=0;l--;)c=*a++*=c+1;}
3

Shakespeare, 365 Bytes

I.Ajax,.Ford,.Act I:.Scene I:.[enter Ajax and Ford]Ajax:Open mind!Scene V:.Ford:Am I nicer than the sum of a big red old cute hard cat a big red old cute joy?Ford:If so,you is the sum of thyself a son!Ford:If not,you is zero!Ford:Open heart!Ajax:you is a big red old cute hard cat.Ajax:Speak mind!Ajax:Open mind!Ford:Am I nicer than zero?Ajax:If so, let us Scene V.

versuche es hier

weniger Golf Version

I.Ajax,.Ford,.
Act I:.
Scene I:.
[enter Ajax and Ford]
Ajax:Open mind!
Scene V:.
Ford:Am I nicer than the sum of a big red old cute hard cat a big red old cute joy?     <- smallest way to 48 (ascii "0") I could think of
Ford:If so,you is the sum of thyself a son!
Ford:If not,you is zero!
Ford:Open heart!
Ajax:you is a big red old cute hard cat.    <- get value of 32 or space
Ajax:Speak mind!                            <- then output it
Ajax:Open mind!
Ford:Am I nicer than zero?
Ajax:If so, let us Scene V.                 <- loop through inputs
— Al R
quelle
— Jo King
3

C ++, 47 Bytes

[](int*a,int*b){for(int c=0;a!=b;)c=*a++*=1+c;}

Ein Lambda, das ein Array an der richtigen Stelle ändert und Start- und Endzeiger erhält.

Probieren Sie es online! (erfordert Javascript)

Generische Version mit 55 Bytes (dies funktioniert für jeden Container mit Elementen des arithmetischen Typs):

[](auto a,auto b){for(auto c=*a-*a;a!=b;)c=*a++*=1+c;};
— Toby Speight
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.