Bir boolean listesinde en uzun gerçekleri bulun. Aynı listeyi, diğer tüm gerçekler sahte olduğunda verin.

Giriş çıkış

Bir liste; Herhangi bir olağan biçim (örneğin, bir dize olarak ayrılmış bir liste).

ayrıntılar

Doğru ve yanlış, dilinizin tipik olarak bu değerler için kullandığı herhangi bir şey veya 1 ve 0 tam sayıları olabilir 10001.

En uzun yol için bir bağ varsa, tüm bağlama yollarını doğru tut ve kısa yolların hepsini tahrif et.

Örnekler

input ↦ output
1,0,1,0,1 ↦ 1,0,1,0,1
1,1,0,1,1,0,1 ↦ 1,1,0,1,1,0,0
1,1,0,1,1,1,0,1,1 ↦ 0,0,0,1,1,1,0,0,0
1,1,1 ↦ 1,1,1
0,0,1 ↦ 0,0,1
0,0 ↦ 0,0
1,1,1,0,0,0,1,1,1,1,0,1,0,0,1,1,0,1,1,1,1,0,0,1,0 ↦ 0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0

(doğrudan https://stackoverflow.com/q/37447114 adresinden )

Jöle , 8 bayt

ṣ0¬¬M¦j0

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Nasıl çalışır

ṣ0¬¬M¦j0  Main link. Argument: A (list of Booleans)

ṣ0        Split at zeroes. This leaves a 2D list of ones.
  ¬       Negate each 1, replacing it with 0.
     ¦    Conditional application:
    M       Yield all maximal indices.
            In lexicographical list comparison, a shorter list of zeroes is less
            than a longer one, so this identifies the longest runs.
   ¬        Negate the items in those lists, changing zeroes back to ones.
      j0  Join, separating by single zeroes.

Haskell, 59 , 58 , 55 , 64 bayt

import Data.List
((=<<)=<<(=<<)(<$).(==).maximum.([1<2]:)).group

Eğlenceli not, bu, herhangi bir değer listesinde çalışır falsy < truthy. Yani False/True, 0/1, 'f'/'t'vb

Not:

Birkaç kişinin işaret ettiği gibi ( @proud haskellerve dahil @nimi) önceki sürüm tüm sahte değerlerin listesinde başarısız oldu. Eklenmesi .([1<2]:)önerdiği gibi, bu sabit olmuştur @proud haskeller. Şimdilik açıklamayı aynı bırakıyorum, çünkü hala mantıklı olduğunu düşünüyorum. Birisi yorum yaparsa, düzenlemenin bir açıklamasını isterim, düzenleyeceğim.

Açıklama:

Önce ben olmadan desugar group, sonra geri ekleyeceğim. İlk önce, kelimelerin gözlerdeki sembollerden daha kolay olduğunu düşünüyorum, bu yüzden birkaç değişiklik yapacağım. ( =<<'Şık' olduğuna dikkat edin , bu yüzden listeler ve işlevler için farklı şekilde geçerlidir. İşlevlerin bindsürümünü arıyorum =<<.)

bind :: (a -> b -> c) -> (b -> a) -> b -> c
bind k f = k =<< f
bind k f = \ r -> k (f r) r

f = ((=<<)=<<(=<<)(<$).(==).maximum)
f = ((bind) concatMap (bind)(<$).equals.maximum)
f = (bind concatMap (bind (<$) . equals . maximum))
f = bind concatMap ((bind (<$)) . equals . maximum))
f = bind concatMap ((\f r -> (<$) (f r) r) . equals . maximum))
f = bind concatMap ((\f r -> (f r) <$ r) . equals . maximum)
f = bind concatMap ((\g r -> (g r) <$ r) . equals . maximum)
f = (\h r -> concatMap (h r) r) ((\g r -> (g r) <$ r) . equals . maximum)
f = \r -> concatMap (((\g r -> (g r) <$ r) . equals . maximum) r) r
f = \r -> concatMap (((\g r -> (g r) <$ r) . equals) (maximum r)) r
f = \r -> concatMap (((\g s -> (g s) <$ s)) (equals (maximum r))) r
f = \r -> concatMap (((\s -> ((equals (maximum r)) s) <$ s))) r
f = \r -> concatMap (\s -> (s == (maximum r)) <$ s) r

f . group = ((=<<)=<<(=<<)(<$).(==).maximum).group
f . group = \r -> concatMap (\s -> (s == (maximum (group r))) <$ s) (group r)

Son ayrıntıların bu vardır x <$ listher eleman değiştirir listile xve group listböler listeşit unsurların parçaları içine kadar. Yani group [1, 1, 2, 3, 3, 3] == [[1, 1], [2], [3, 3, 3]].

Hepsini özetlemek için, işlev, değerler listesini yalnızca true ve yalnızca false gruplarına böler. Sonra her grup için, her bir öğeyi ifadenin sonucuyla değiştirin this is the biggest group(en büyük grup en büyük grup trueolacaktır) ve grupları birleştirin.

Tarafından kaydedilen dört bayt @Zgarb

Retina, 47 43 36

0
!
T`p`0`\b(1+)\b(?<=(?=.*1\1).*)|!

Çevrimiçi deneyin! veya tüm test durumlarını deneyin

4 byte golf için msh210'a teşekkürler!

Ayrıca 7 bayt Martin'e büyük teşekkür!

Açıklama:

0
!

Tümünü 0s ile değiştirin !. Bu, eşleştirme gruplarının 1şimdi olduğu gibi daha kısa olmasını sağlamak için yapılır 1!ve aralarında dizgenin başlangıcına veya sonuna eşleşen !1bir kelime sınırına ( \b) sahip olur.

T`p`0`

Bu, girişten geriye doğru çıktıktan sonra regex uyguladıktan sonra, her eşleşmede her yazdırılabilir ascii karakterini bir 0karaktere çevirdiğini söyleyen bir yapılandırma seçeneğidir .

\b(1+)\b(?<=(?=.*1\1).*)|!

Bu regex 1, sıfırlarla çevrili olan gruplarla eşleşir , ancak 1dizenin hiçbir yerinde bunu takip edemez . Bunlar sahte olacak azami olmayan gruplardır. Ayrıca bu, !tekrar 0s'ye dönüştürmek için eklediğimiz karakterlerle de eşleşir .

MATL, 14 bayt

Y'yy*X>y=b*wY"

Çevrimiçi Deneyin!

Tüm test durumları ile değiştirilmiş sürüm

açıklama

        % Implicitly grab the input as an array
Y'      % Perform run-length encoding of the input. Yields an array of values and an array
        % of run-lengths
yy      % Copy these outputs
*       % Multiply the values (booleans) by the run-lengths. This will zero-out all
        % zero-valued runs so we don't consider them when computing the longest run.
X>      % Compute the longest run of 1's
y       % Copy the run lengths vector
=       % Determine which runs are the same length as the longest run of ones
b*      % Bubble-up the values from the run-length encoding and multiply element-wise
        % With this boolean. This substitutes all 1's that are not in the longest run
        % of ones with 0's
w       % Flip the run-lengths and values on the stack
Y"      % Perform run-length decoding using these substituted values
        % Implicitly display the resulting boolean

Python 2, 62 bayt

lambda s:'0'.join(`1-(t+'1'in s)`*len(t)for t in s.split('0'))

İdeone üzerinde test et .

Nasıl çalışır

s.split('0')giriş dizgisini s sıfıra veya daha fazla 1 'in çalışmasına böler

Her çalışma için t , s 'nint+'1' bir alt dize olup olmadığını kontrol ederiz .

• Eğer durum bu ise, çalıştırma maksimal değil, t+'1'in sgeri True , 1-(t+'1'in s)geri doğru = 0 - 1 ve çalıştırmak bir çalışma ile yerine 0 'aynı uzunlukta s.

• Değilse, çalışma maksimum olduğu t+'1'in sdönüş yanlış , 1-(t+'1'in s)geri 1-1 = False ve çalıştırmak bir çalışma ile yerine 1 tek başına, örneğin, 'aynı uzunlukta s.

Son olarak, '0'.jointüm çıkarılmış geri 0 's.

J, 25 bayt

[:(}.=>./)@;0<@(*#);.1@,]

Bu, 0-1 dizisini alan ve döndüren tek boyutlu bir fiildir. Bu şekilde kullanın:

   f =: [:(}.=>./)@;0<@(*#);.1@,]
   f 1 1 0 1 1 1 0 1 1
0 0 0 1 1 1 0 0 0

açıklama

[:(}.=>./)@;0<@(*#);.1@,]  Input is y.
            0          ,]  Prepend 0 to y, and
                   ;.1@    cut the result along occurrences of 0,
                           so that each piece begins with a 0.
               (*#)        Multiply each piece element-wise by its length,
             <@            and put it in a box.
                           Without the boxing, the pieces would go in a 0-padded array.
           ;               Join the pieces back together.
                           Now all runs of 1 have been replaced by runs of (1+length of run).
[:(      )@                Apply verb in parentheses:
   }.                        remove the prepended 0,
     =                       form the 0-1 array of equality with
      >./                    the maximum value.

Pyth, 26 24 23 21 bayt

M,G&HGJrgMrQ8 9qReSJJ

Test odası.

• Kullanır 1/0veya true/falsegiriş.
• true/falseÇıkışta kullanır .

açıklama

M,G&HGJrgMrQ8 9qReSJJ

           Q      input
          r 8     run-length encode
        gM        convert each run of 1 to their length
                  for example: [1,1,1,0,1,1] will be
                  converted to [3,3,3,0,2,2]
                  in the run-length encoded version
                  [1,1,1,0,1,1] will be [[3,1],[1,0],[2,1]]
                  [3,3,3,0,2,2] will be [[3,3],[1,0],[2,2]]
                  therefore basically [G,H] becomes [G,H and G]
                  which is what the code below does:
M,G&HG            def g(G,H): return [G,H and G]
       r      9   run-length decode
      J           store to J

               qReSJJ

                R   J   in each element of J
               q eSJ    check if equal to maximum of J

Önceki 23 bayt

M,G&HGJrgMrQ8 9msqdeSJJ

Test odası.

• Kullanır 1/0veya true/falsegiriş.
• 1/0Çıkışta kullanır .

Önceki 24 bayt

Jrm,hd&edhdrQ8 9msqdeSJJ

Test odası.

• Kullanır 1/0veya true/falsegiriş.
• 1/0Çıkışta kullanır .

Önceki 26-bayt

rm?nhdeS.u&YhNQ0,hd0drQ8 9

Test odası.

• Kullanır 1/0veya true/falsegiriş.
• 1/0Çıkışta kullanır .

Oracle SQL 12.1, 137 135 bayt

SELECT REPLACE(REPLACE(REPLACE(:1,m,2),1,0),2,m)FROM(SELECT MAX(TRIM(COLUMN_VALUE))m FROM XMLTABLE(('"'||REPLACE(:1,0,'",0,"')||'"')));

Un-golfed

-- Replace the max value with 2
-- Then replace every 1 with 0
-- Then replace 2 with the max value
SELECT REPLACE(REPLACE(REPLACE(:1,m,2),1,0),2,m)
FROM   ( -- Split on 0 and keep the max value
         SELECT MAX(TRIM(COLUMN_VALUE))m 
         FROM XMLTABLE(('"'||REPLACE(:1,'0','",0,"')||'"'))
       );

Giriş, tek karakter kullanın. Ör: '1100111'

Mathematica , 46 41

1-Join@@Sign[1~Max~#-#]&[#*Tr/@#]&@*Split

Listelerinde çalışır 0ve 1. Diğer cevaplara bakana kadar çok iyi yaptığımı sanıyordum!

46 karakter versiyonu için açıklama; Daha fazla geliştiremediğimde güncelleme yapacağım.

Bu kodun açıklaması istendi.
Kod dışı bir golf eşdeğeri (sürüm 10 operatör formunu kullanarak):

RightComposition[
  Split,
  Map[# Tr@# &],
  # - Max[1, #] &,
  UnitStep,
  Apply[Join]
]

Bu, yukarıdan aşağıya sırayla uygulanan beş adımdan (alt fonksiyonlar) oluşan bir fonksiyon anlamına gelir.

• Split: aynı elemanların parçalarına ayrılma: {1,1,0,1,1,0,1} ↦ {{1,1}, {0}, {1,1}, {0,0}}

• Map[# Tr@# &]: Her alt liste için ( Map) onu ( #) toplamıyla çarpın (vektör izi, Tr): {1,1} ↦ {2, 2}

• # - Max[1, #] &listelerden herhangi bir yerde görünen maksimum değeri her bir elementten veya hangisi daha yüksekse çıkartın. (Biri, tüm sıfırların durumunu ele alır.)

• UnitStep: her öğeye uygulanan, x <0 için 0, x> = 0 için 1'dir.

• Apply[Join]: Alt listelerde tek bir listeye katılın. FlattenVeya ile de yapılabilirdi Catenate, ama kısaca Join@@daha özlü.

C, 135 129 bayt

Çevrimiçi dene

m,c,i,d,j;f(int*l,int s){while(i<s)c=l[i++]?c+1:0,m=c>m?c:m;while(j<s)if(l[j++])d=d+1;else if(d<m)while(d)l[j-1-d--]=0;else d=0;}

Ungolfed

m,c,i;
f(int*l,int s)
{
    // obtain max
    while(i<s)
        c = l[i++] ? c+1 : 0,
        m = c>m ? c : m;

    c=0,i=0;

    // remove smaller segments
    while(i<s)
        if(l[i++]) c=c+1;
        else if(c<m) while(c) l[(i-1)-c--]=0;
        else c=0;
}

JavaScript (ES6), 56 bayt

s=>s.replace(/1+/g,t=>t.replace(/1/g,+!~s.indexOf(t+1)))

1s'nin tüm çalışmalarını kontrol ederek ve 1s'den uzun bir çalışma dizesini arayarak ölçülen çalışma (eşit) en uzun olmadıkça karakterleri 0s ile değiştirerek çalışır.

Önceki 72 bayt özyinelemeli çözüm:

f=s=>/11/.test(s)?f(s.replace(/1(1*)/g,"0$1")).replace(/0(1+)/g,"1$1"):s

1s koşusu yoksa hiçbir şey yapmaz (yani en fazla tek 1). Aksi takdirde, 1her birini 1veya çalıştırdığı birini çıkartır , daha sonra kısa çalışmalarda özyinelemeli olarak çağırır, sonra 1(şimdi eşit derecede uzun) çalışmalara bir tane ekler . Özyinelemeli aramaların sayısı en uzun sürenin uzunluğundan azdır.

Julia, 51 bayt

s->replace(s,r"1+",t->map(c->c-contains(s,"1"t),t))

Çevrimiçi deneyin!

Nasıl çalışır

replacebulur, bir veya daha fazlasının Bütün çalışır 1 'girdi dizesi içinde s ın regex aracılığıyla r"1+"ve lambda çağıran t->map(c->c-contains(s,"1"t),t)yedek dizesini belirlemek için.

Lambda c->c-contains(s,"1"t), tüm karakterleri t karakterlerinin üzerinde eşler .

• Eğer "1"t(birleştirme) de bir alt s , çalıştırma, maksimum değildir containsdöner doğru ve c-contains(s,"1"t)döner '1' - gerçek = '0' her yerine 1 'o vadede s 0 s'.

• Eğer "1"t(birleştirme) de bir alt değildir s , çalışma maksimum olduğu containsdöner sahte ve c-contains(s,"1"t)döner yanlış = '1' - '1' , değiştirilmemiş çalıştırmak bırakır.

APL, 22 karakter

(⊣=⌈/)∊(⊣×+/¨)(~⊂⊣)0,⎕

İngilizce (bloklar halinde sağdan sola):

• girişe 0 hazırla
• her 0 ile başlayan kutu
• her bir kutuyu toplamıyla çarp
• düzleştirmek
• 1, sayı max'a eşitse, 0

Java 8, 205 bayt

Bu, a için bir lambda ifadesidir Function<String,String>:

s->{int x=s.length();for(String t="1",f="0";s.indexOf(t+1)>=0;t+=1){s=s.replaceAll(0+t+0,0+f+0);if(s.indexOf(t+0)==0)s=s.replaceFirst(t,f);if(s.lastIndexOf(0+t)==--x-1)s=s.substring(0,x)+f;f+=0;}return s;}

giriş / çıkış, Stringtrue değerinin 1, false ise 0 ile temsil edildiği yerdir. Değerleri ayıran sınırlayıcı karakterler yoktur.

açıklama ile kod:

inputString -> {
  int x = inputString.length();
  //starting with the truth combination "1",
  //loop until the input string does not contain the combination appended with another "1"
  //with each consecutive loop appending a "1" to the combination
  for( String truthCombo = "1", falseCombo = "0"; inputString.indexOf( truthCombo + 1 ) >= 0; truthCombo += 1 ) {
    //all instances in the input string 
    //where the combination has a "0" on either side of it
    //are replaced by "0"'s
    inputString = inputString.replaceAll( 0 + truthCombo + 0, 0 + falseCombo + 0 );
    //if the combination followed by a "0"
    //is found at the beginning of the input string
    //replace it with "0"'s
    if( inputString.indexOf( truthCombo + 0 ) == 0 )
      inputString = inputString.replaceFirst( truthCombo , falseCombo );
    //if the combination preceeded by a "0"
    //is found at the end of the input string
    //replace it with "0"'s
    if( inputString.lastIndexOf( 0 + truthCombo ) == --x - 1 )
      inputString = inputString.substring( 0, x ) + falseCombo;
    falseCombo += 0;
  }
  return inputString;
}

test durumları için ideone bakın

Clojure, 137 bayt

#(let[v(map(juxt first count)(partition-by #{1}%))](mapcat(fn[t](repeat(t 1)(if(=[1(apply max(map(fn[[f c]](if(= 1 f)c 0))v))]t)1 0)))v))

İlk önce girdiyi ardışık sıfırlara ve bunlara ayırır ve bunları bölümlerin ilk elementinin ve elementlerin sayısının “tuples” ına eşler. Daha sonra, birlerin maksimum uzunluk dizisi olup olmamasına bağlı olarak, gerekli sıfır veya sıfır sayısını tekrarlar.

Daha az golf oynadı:

(def f #(let [v(map(juxt first count)(partition-by #{1}%))
              m(apply max(map(fn[[f c]](if(= 1 f)c 0))v))]
           (mapcat (fn[[f c]](repeat c(if(=[1 m][f c])1 0))) v)))

Perl 5, 68 bayt

67 -peyerine , artı 1-e

y/0/ /;$_<${[sort@a]}[-1]&&y/1/0/for@a=split/\b/;$_=join"",@a;y; ;0

0s ve 1s dizesini (birleştirme) bekler ve yazdırır.