Tâche

Étant donné un tableau non vide de 0et 1, divisez par deux la longueur des séries de 0.

Contribution

Un tableau de 0et 1. Format acceptable:

• Vrai tableau dans votre langue
• Chaîne séparée par des sauts de ligne 0et1
• Chaîne contiguë de 0et1
• Tout autre format raisonnable

Par exemple, les trois entrées suivantes sont toutes acceptables:

• [1, 0, 0, 1]
• "1\n0\n0\n1"(où \nest un saut de ligne U + 000A)
• "1001"

Vous pouvez supposer que les séries de 0seront de même longueur .

Production

Un tableau de 0et 1, dans les formats acceptables ci-dessus.

Cas de test

input ↦ output
[1,0,0,1,0,0,1] ↦ [1,0,1,0,1]
[1,1,0,0,1,1,0,0,1] ↦ [1,1,0,1,1,0,1]
[1,1,0,0,1,1,1,0,0,1,1] ↦ [1,1,0,1,1,1,0,1,1]
[1,1,1] ↦ [1,1,1]
[0,0,1] ↦ [0,1]
[0,0] ↦ [0]
[1,1,1,0,0,0,0,1,1,1,1,0,0,1,0,0,1,1,0,0,1,1,1,1,0,0,1,0,0] ↦ [1,1,1,0,0,1,1,1,1,0,1,0,1,1,0,1,1,1,1,0,1,0]

Notation

C'est du code-golf . La réponse la plus courte en octets l'emporte.

Des échappatoires standard s'appliquent.

Rétine , 4 octets

00
0

Essayez-le en ligne!

05AB1E , 5 octets

00¤.:

Essayez-le en ligne!

Explication

00     # push 00
  ¤    # tail, pushes 0
   .:  # replace

Haskell , 33 octets

f(0:0:r)=0:f r
f(x:r)=x:f r
f e=e

Essayez-le en ligne! Utilisation: f[1,1,0,0,1,1,0,0,1]. Itère sur la liste et remplace deux zéros consécutifs par un zéro.

C (gcc) , 35 octets

f(char*s){while(*s)putchar(*s),*s++-48?:s++;}

48 est le code ascii de '0'

meilleure version 43 octets comme suggéré par Neil

f(char*s){while(*s)putchar(*s),s+=2-*s%2;}

un autre 40 octets cette fois (encore une fois comme suggéré par Neil & VisualMelon) :)

f(char*s){for(;*s;s+=50-*s)putchar(*s);}

puis 35 octets grâce à Khaled.K

f(char*s){*s&&f(s+50-putchar(*s));}

Essayez-le en ligne!

sed , 8 octets

s/00/0/g

Essayez-le en ligne!

Octave, 22 octets

@(s)strrep(s,'00','0')

Vérifiez tous les cas de test ici.

Il s'agit d'une fonction anonyme qui prend une chaîne sur le format '1001000011'en entrée et remplace deux zéros consécutifs par un seul zéro.

Java, 50 octets

String f(String s){return s.replaceAll("00","0");}

Essayez en ligne

Haskell , 28 octets

f(h:t)=h:f(drop(1-h)t)
f e=e

Essayez-le en ligne!

Prend récursivement le premier élément, laissant tomber le second si le premier est nul, jusqu'à la liste des vides. Si la première entrée est h, alors les premières 1-hsont supprimées du reste.

Japt , 7 6 5 octets

d'0²0

Essayez-le en ligne!

Remplace simplement chaque série de deux zéros dans l'entrée par un zéro. Utilise une entrée de chaîne (c. "1001001"-à-d.).

PHP, 26

<?=strtr($argn,["00"=>0]);

remplacez tout simplement 00par 0.

Alice , 13 octets

/oe00/
@iS0e\

Essayez-le en ligne!

Explication

/.../
@...\

Il s'agit d'un modèle simple pour les programmes linéaires qui fonctionnent entièrement en mode Ordinal. L'initiale /reflète l'IP pour se déplacer vers le sud-est, puis elle rebondit en diagonale de haut en bas à travers le code jusqu'à ce que les miroirs à la fin. Ceux-ci compensent simplement la position d'un pour qu'au retour l'IP traverse les cellules restantes. En lisant le code de cette manière en zigzag, cela devient:

ie00e0So@

Il s'agit d'une simple substitution de chaîne:

i   Read all input.
e   Push an empty string.
00  Append two zeros to create the string "00".
e   Push an empty string.
0   Append a zero to create the string "0".
S   Substitute all occurrences of "00" in the input with "0".
o   Output the result.   
@   Terminate the program.

Il existe quelques autres façons de pousser les deux chaînes, par exemple '00'0oue000t , mais je n'ai rien trouvé qui bat 5 octets (et je devrais raser deux octets pour pouvoir raccourcir le programme).

Prolog (SWI) , 42 octets

[0,0|T]*[0|R]:-T*R.
[H|T]*[H|R]:-T*R.
H*H.

Essayez-le en ligne!

Java , 131 123 octets

int[]f(int[]a){int c=0,i=0,l=a.length;for(int x:a)c+=1-x;int[]r=new int[l-c/2];for(c=0;c<l;c+=2-a[c])r[i++]=a[c];return r;}

Essayez-le en ligne!

JavaScript (ES6), 26 21 octets

Prend l'entrée sous forme de chaîne et renvoie une chaîne.

s=>s.replace(/00/g,0)

Essayez-le

f=
s=>s.replace(/00/g,0)
i.addEventListener("input",_=>o.innerText=f(i.value))
console.log(f("1001001")) // "10101"
console.log(f("110011001")) // "1101101"
console.log(f("11001110011")) // "110111011"
console.log(f("111")) // "111"
console.log(f("001")) // "01"
console.log(f("00")) // "0"
console.log(f("11100001111001001100111100100")) // "1110011110101101111010"

<input id=i><pre id=o>

Lua, 33 octets

print((io.read():gsub("00","0")))

Prend une chaîne via l'entrée et condense les doubles zéros. Facile.

Gelée , 8 octets

ṣ1j1,1m2

Essayez-le en ligne!

D'autres réponses dans des langues sans .replace()ou similaire pourraient éventuellement utiliser cette astuce.

Explication

ṣ1j1,1m2 - (duplicates the 1s, then halves all lengths)
ṣ1       - split by the element 1
  j1,1   - join the elements with the two-element list 1,1
      m2 - get every second element

Alice , 12 10 octets

2 octets économisés grâce à Martin Ender

i.h%.7%$io

Essayez-le en ligne!

Explication

Il s'agit d'un code 1-D fonctionnant en mode cardinal, il est donc facile de suivre son flux:

i                   Read a byte from input (pushes -1 on EOF)
 .h                 Duplicate it and add 1 to the copy
   %                Compute n%(n+1). This will exit with an error on n==-1
                    and return n for any non-negative n.
    .7%             Duplicate the input again and compute its value modulo 7
                    This returns 6 for '0' (unicode value 48) and 0 for '1'
                    (unicode value 49)
       $i           If this last result was not 0, input another number.
                    This ignores every other '0' in the input
                    and moves to the following number (another '0')
         o          Output the last byte read

                    At the end, wrap back to the beginning of the line

Python (liste des E / S), 36 octets

f=lambda l:l and l[:1]+f(l[2-l[0]:])

Essayez-le en ligne!

Prend récursivement le premier élément, puis supprime celui qui reste si le premier était nul.

38 octets:

lambda l:eval(`l`.replace('0, 0','0'))

Essayez-le en ligne Cela prend une liste Python et génère une liste Python en remplaçant sa représentation sous forme de chaîne. Les E / S de chaîne permettraient une solution plus directe et plus courte, telle que

lambda s:s.replace('00','0')

pour le '1001' format.

APL (Dyalog) , 9 octets

'00'⎕R'0'

Essayez-le en ligne!

Perl 5, 7 + 1 (indicateur -p) = 8 octets

<>if/0/

Prend les entrées sous forme de nombres séparés par des sauts de ligne. Saute la ligne suivante s'il voit un zéro.

V , 4 octets

òf0x

Essayez-le en ligne!

ò    ' Recursively (until we error)
 f0  ' Go to the next zero (errors when there are no zeros left)
   x ' Delete it

MATL , 5 octets

FFOZt

Essayez-le en ligne!

Explication

Ceci est similaire à la réponse Octave de Stewie Griffin :

FF     % Push [0 0]
O      % Push 0
Zt     % Implicitly take input. Replace [0 0] by 0. Implicitly display

8 octets

vy~f2L)(

Cela évite le remplacement de chaîne / tableau intégré.

Essayez-le en ligne!

Explication

Considérez la saisie [1,0,0,1,0,0,1]comme exemple:

v      % Concatenate stack (which is empty): pushes []
       % STACK: []
y      % Implicit input. Duplicate from below
       % STACK: [1,0,0,1,0,0,1], [], [1,0,0,1,0,0,1]
~f     % Negate, find: gives indices of zeros
       % STACK: [1,0,0,1,0,0,1], [], [2,3,5,6]
2L     % Push [2,2,1i]. As an index, this is interpreted as 2:2:end
       % STACK: [1,0,0,1,0,0,1], [], [2,3,5,6], [2,2,1i]
)      % Reference indexing. This selects the even-indexed entries
       % STACK: [1,0,0,1,0,0,1], [], [3,6]
(      % Assignment indexing. This deletes the specified entries
       % (assigns them the empty array). Implicitly display
       % STACK: [1,0,1,0,1]

Brachylog , 10 octets

ḅ{cẹ|ḍh}ᵐc

Essayez-le en ligne!

Pas sûr que ce soit encore optimal…

Explication

Cela exploite le bogue qui, csur une liste d'entiers comportant des zéros non significatifs, échouera.

ḅ               Blocks; group consecutive equal elements together
 {     }ᵐ       Map on each block:
  c               It is possible to concatenate the block into an int (i.e. it contains 1s)
   ẹ              Split it again into a list of 1s
    |             Else
     ḍh           Dichotomize and take the head
         c      Concatenate the blocks into a single list

C #, 191 octets

string a(string s){var l=(s+'1').ToCharArray();s="";int b=0;for(int i=0;i<l.Length;i++){if(l[i]=='1'){if(b>0){s+=new string('0',b/2);b=0;}s+=l[i];}else b++;}return s.Substring(0,s.Length-1);}

Essayez-le en ligne!

Ce n'est ni propre ni court, mais ça marche.

Prend les entrées sous forme de chaîne de caractères contigus, les sorties dans le même format

Explication:

string a(string s){                  //Define method a that takes input string s and returns a string
  var l=(s+'1').ToCharArray();       //Add a 1 to the end of s and split into char array l
  s="";                              //Empty s
  int b=0;                           //Initialize int b with value 0
  for(int i=0;i<l.Length;i++){       //Loop through l
    if(l[i]=='1'){                   //If current char is 1
      if(b>0){                       //If b is not 0
        s+=new string('0',b/2);      //Add half the amount of 0s we've counted to s
        b=0;                         //Reset b
      }                              //End if b is not 0
      s+=l[i];                       //Add current char to s
    }                                //End if current char is 1
    else b++;                        //If current char is not 1, increment b
  }                                  //End loop
  return s.Substring(0,s.Length-1);  //Return string minus last char
}                                    //End method

Remarque

Oui, je sais que cela pourrait simplement être fait en utilisant s.Replace("00","0") , mon objectif était d'éviter d'utiliser la solution évidente. Après tout, l'intérêt de PPCG est de s'amuser, non? ;)

Pyth, 8 octets

:z"00"\0

Lien d'essai.

Explication:

:z"00"\0 Takes unquoted contiguous 1-line input.
 z       Initialized to unevaluated first input line (Q won't be any shorter)
  "00"   Matching regex pattern /00/g
      \0 Substitution string "0"
:        Regex find-and-replace

Awk - 18 octets

Essayez d'abord de faire quoi que ce soit avec Awk afin qu'il soit possible de le jouer davantage.

{gsub(00,0);print}

Usage: echo "1001001" | awk '{gsub(00,0);print}'

Lot, 24 octets

@set/ps=
@echo %s:00=0%

Prend entrée sur STDIN. Un peu compétitif pour une fois.

Lisp commun, SBCL, 48 32 octets

-16 octets grâce à Julian Wolf

(format t"~{~[0~*~;1~]~}"(read))

contribution:

(1 0 0 0 0 1 1 1 0 0)

production:

1001110

Explication

Nous lisons la liste des entrées. La liste est utilisée dans la formatfonction. Nous le parcourons en sortie 1si l'élément est 1et en sortie 0et en sautant l'élément suivant de la liste pour 0.

Mathematica, 24 octets

StringReplace["00"->"0"]

Une fonction qui attend une chaîne de "0"s et de "1"s et renvoie une chaîne similaire. Syntaxe explicite. Mathematica possède de nombreux modules de transformation; la clé est d'en utiliser une qui transforme chaque sous-expression pertinente (contrairement à /.) mais ne passe par l'expression qu'une seule fois (contrairement //.).

Gelée , 10 octets

Œg¹m2$S?€F

Essayez-le en ligne!

Explication

Œg¹m2$S?€F
Œg          - Group runs of equal elements
        €   - To each run...
      S?    - If sum is truthy,
  ¹         -   return the run as it is
   m2$      - Else return every second element of the run.