Şimdi hep beraber


24

1'den 9'a kadar olan rakamların bir listesi göz önüne alındığında, her bir basamağın tek bir bitişik blok olarak gruplanmış olup olmadığına bakın. Başka bir deyişle, aynı rakamın hiçbiri farklı rakamlarla ayrılmaz. Bir rakam hiç görünmüyorsa tamamdır. En az bayt kazanır.

Giriş: 1 ile 9 arasındaki rakamların boş olmayan bir listesi. Ondalık sayı, dize, liste veya benzeri bir sıralama olabilir.

Çıkış: tutarlı Truthy tüm rakamlar bitişik bloklar gruplandırılır, değer ve tutarlı bir Falsey değiller ise değer.

Gerçek durumlar:

3
51
44999911
123456789
222222222222222222222

Yanlış durumlar:

818
8884443334
4545
554553
1234567891


2
Singleton dizelerinin bir listesi kabul edilebilir bir giriş formatı olur mu?
Dennis,

Evet, singletons iyi durumda.
xnor

Birisi bana bu problem için en etkili algoritmanın ne olacağını söyleyebilir mi? Yoksa bu konunun altında bakabileceğim daha genel bir sorun mu var?

@ amt528 Her basamakta yineleyerek ve ilkinden hiçbirinin geçmediğini kontrol ederek doğrusal zamanda yapabilirsiniz.
xnor

Nasıl uygulandığına dair bir örnek verebilir misiniz?

Yanıtlar:


18

Python 3, 38 34 33 bayt

lambda s:s==sorted(s,key=s.index)

Bu, argüman olarak rakam veya singleton dizelerinin bir listesini bekler. İdeone üzerinde test et .

4 baytlık golf oynamak için @xsot'a teşekkürler!

1 byte kapalı golf için @ immibis için teşekkürler!


Bunun yerine dizelerin listesini kabul etme izniniz varsa, bunu lambda s:s==sorted(s,key=`s`.find)
0:19 saatinde

Ah, bir liste almaya çalıştım, ama backticks kullanmayı düşünmedim ... OP'ye soracağım.
Dennis,

Bir şeyi mi özlüyorum - neden sadece kullanamıyorsun s.find?
kullanıcı253751,

@ immibis ssingleton dizelerinin bir listesi olmalı (veya skarşılaştırma için listeyi yayınlamalıyım ) ve list.findtanımlanmamış ...
Dennis

@Dennis s.indexo zaman? Benim için iş gibi görünüyor.
kullanici253751

14

JavaScript (ES6), 27 bayt

s=>!/(.)(?!\1).*\1/.test(s)

İki bitişik olmayan rakam aramak için negatif görünüm kullanır. Eğer en az iki tane rakam mevcutsa, ilk rakam farklı bir rakamdan önce gelecek şekilde seçilebilirler.


1
Veya, sadece bir regex XD kullanın. Bu da işe yarıyor.
Conor O'Brien,

1
ahem Retina ahem
John Dvorak

13

05AB1E , 4 bayt

Kod:

Ô¹ÙQ

Açıklama:

Ô     # Push connected uniquified input. E.g. 111223345565 would give 1234565.
 ¹    # Push input again.
  Ù   # Uniquify the input. E.g. 111223345565 would give 123456.
   Q  # Check if equal, which yields 1 or 0.

CP-1252 kodlamasını kullanır .

Çevrimiçi deneyin!


2
Sen ... sadece jöleyi yendin ... Bunun mümkün olduğunu hiç düşünmedim ...
Bálint

11

Jöle , 5 bayt

ĠIFPỊ

Çevrimiçi deneyin!

Nasıl çalışır

ĠIFPỊ  Main link. Input: n (list of digits or integer)

Ġ      Group the indices of n by their corresponding values, in ascending order.
       For 8884443334, this yields [[7, 8, 9], [4, 5, 6, 10], [1, 2, 3]].
 I     Increments; compute the all differences of consecutive numbers.
       For 8884443334, this yields [[1, 1], [1, 1, 4], [1, 1]].
  F    Flatten the resulting 2D list of increments.
   P   Product; multiply all increments.
    Ị  Insignificant; check if the product's absolute value is 1 or smaller.

Beş byte mi dedin? Bu ne biçim bir kodlama?
John Dvorak

4
Jelly, her bir tek bayt olarak anladığı 256 karakterin her birini kodlayan kendi kod sayfasına sahiptir .
Dennis,

9

Pyth, 6 5 bayt

FryAmTheEggman sayesinde 1 bayt

SIxLQ

Burada Python çözümünden esinlenilmiştir .

Test odası

Açıklama:

SIxLQ
  xLQ   Map each element in the input to its index in the input. Input is implicit.
SI      Check whether this list is sorted.

3
SIxLQiş gibi görünüyor.
FryAmTheEggman

Bu bir dahi.
Maltysen

1
İkincisi Qdüzgün bir şekilde ayrıştırılmış gibi görünmüyor, argüman sırasını veya başka bir şeyi değiştiriyor, bu yüzden hepsini alırsınız 0ve her zaman doğrudur. İşte bir test takımı.
FryAmTheEggman

8

R, 66 48 46 43 38 bayt

function(s)!any(duplicated(rle(s)$v))

Bu, girişi basamakların bir vektörü olarak kabul eden ve bir boolean döndüren bir işlevdir. Aramak için değişkene atayın.

En kısa değil ama eğlenceli bir yaklaşım olduğunu düşündüm. Length komutunu giriyoruz ve girdiyi kodluyoruz. Değerlerin listesi kopya içeriyorsa FALSE, geri dönün , yoksa geri dönün TRUE.

Tüm test durumlarını çevrimiçi olarak doğrulayın

MickyT sayesinde 20 bayt, Albert Masclans sayesinde 3, mnel sayesinde 5 teşekkür!


7

MATL , 8 bayt

t!=tXSP=

Çıktı, yalnızca truthy için olanları içeren bir dizi veya falsey için en az bir sıfır içeren bir dizidir.

Çevrimiçi deneyin!

açıklama

22331Koşulu sağlayan girdiyi düşünün . Her karakterin birbirine eşit olup olmadığının test edilmesi 2B dizi verir.

1 1 0 0 0
1 1 0 0 0
0 0 1 1 0
0 0 1 1 0
0 0 0 0 1

Nihai sonuç , bu dizinin (atomik olarak kabul edilir) sıraları (sözlükbilimsel) azalan bir düzendeyse , sıradışı olmalıdır . Karşılaştırma için, giriş 22321diziyi verir

1 1 0 1 0
1 1 0 1 0
0 0 1 0 0
1 1 0 1 0
0 0 0 0 1

sıraların sıralanmadığı.

t!   % Take string input. Duplicate and tranpose
=    % Test for equality, element-wise with broadcast: gives a 2D array that
     % contains 0 or 1, for all pairs of characters in the input
t    % Duplicate
XS   % Sort rows (as atomic) in increasing order
P    % Flip vertically to obtain decreasing order
=    % Test for equality, element-wise

5

Retina , 17 bayt

M`(.)(?!\1).+\1
0

Çevrimiçi deneyin! (Tüm test durumlarını bir kerede çalıştırmak için hafifçe değiştirilmiş.)

İlk regex maçları rakam olan bir olsun, böylece diğer rakamlar ile ayrılmış 0arasında herhangi bir yerde geçerli girişler için ve 1ve 9geçersiz girişler için (nedeniyle bir açgözlülükle için .+, biz fazla alamayan n-1için maçları nfarklı basamak).

Sonucun doğruluğunu tersine çevirmek için geçerli girdiler ve geçersiz olanlar için 0olan s sayısını sayarız .10


Daha kısa bir tane yaptım, ancak bunun yerine bir yorum olması sizin için yeterince yakın. Maç yerine AntiGrep kullanın, sonra son satırı kaldırın: A`(.)(?!\1).+\115 bayt için. Ayrıca çoklu girişler için çalışır. Gerçek, giriş, sahte, hiçbir şey değildir. Biri, Martin’i kendi dilinde dışlamaz. :)
mbomb007 22.06.2016

@ mbomb007 Ben aslında bunu düşündüğümü düşünüyorum, ama ne yazık ki, meydan okuma tutarlı bir truthy (ve sahtekarlık) değeri ister, bu nedenle girdiyi truthy olarak yazdırmaya izin verilmez.
Martin Ender

5

Java, 161 156 bayt

Çünkü Java ...

Utanmadan çalmak gelen regex ödünç Bu cevap ben diziler ve matematik manipülasyon ile bu yapmaya çalışıyor başladı çünkü ancak iğrenç karmaşık var ve regex iyi olarak bu sorun için herhangi bir araçtır.

import java.util.regex.*;public class a{public static void main(String[] a){System.out.println(!Pattern.compile("(.)(?!\\1).*\\1").matcher(a[0]).find());}}

Ungolfed:

import java.util.regex.*;

public class a {
    public static void main(String[] args) {
        System.out.println(!Pattern.compile("(.)(?!\\1).*\\1").matcher(args[0]).find());
    }

Mantıklı bir Java kullanıcısı gibi ortaya çıktı:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class  {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("(.)(?!\\1).*\\1");
        Matcher m = p.matcher(args[0]);
        System.out.println(!m.find());
    }
}

3
like a sensible Java personJava kullanmayacaktı.
kedi,

Diğer çözümler sadece bir işlev sunmakta, onu çok daha kısa hale getirecektir. Gibi bir şeys->s.match("(.)(?!\\1).*\\1")
Andreas

2
Fakat o zaman cevabın ayrıntılarında isyan edemedik.
JamesENL,


4

Ruby, 23 bayt

Anonim işlev Bir dizeyi kabul eder. Regex strat.

->n{/(.)(?!\1).*\1/!~n}

Regex dağılımı

/(.)(?!\1).*\1/
 (.)            # Match a character and save it to group 1
    (?!\1)      # Negative lookahead, match if next character isn't
                #  the same character from group 1
          .*    # Any number of matches
            \1  # The same sequence as group 1

!~ Dize içinde regex eşleşmesi yoksa, return true yoksa ve aksi takdirde return anlamına gelir false.



4

Matl, 13 11 bayt

u"G@=fd2<vA

Luis Mendo'ya teşekkürlerİki baytı kurtardığı !

Çevrimiçi Deneyin!

açıklama

        % Grab the input implicitly
u       % Find the unique characters
"       % For each of the unique characters
    G   % Grab the input again
    @=  % Determine which chars equal the current char
    f   % Find the locations of these characters
    d   % Compute the difference between the locations
    2<  % Find all index differences < 2 (indicating consecutive chars)
    v   % Vertically concatenate all stack contents
    A   % Ensure that they are all true
        % Implicit end of the for loop

Girdileri tırnak işaretleri ile alabilir (varsayılan olarak izin verilir) ve kaldırabilirsiniz j. Ayrıca, vAdöngü içinde hareket edebilir ve kaldırabilirsiniz]
Luis Mendo

@LuisMendo Teşekkürler! Y&İçeri koymakla uğraşmıştım ama bu işe yaramadı çünkü fd2<boş olabilir. vAİçinde hareket olsa harika çalışıyor! Ayrıca, uniquetonlarca baytı almayan bir kararlılığımız olmasını çok isterdim .
Suever,

Şimdi kararlı benzersiz önceden tanımlanmış dize yerine bir sayı kullanarak, biraz daha az sürer. Yine de gelecekte daha kısa bir sürüm ekleyebilirim. Ya da sadece uvarsayılan olarak kararlı hale getirin ( Sdaha sonra iki bayt içerebilir ). Ne düşünüyorsun?
Luis Mendo

3

Haskell, 44 bayt

import Data.List 
((==)<*>nub).map head.group

Kullanım örneği: ((==)<*>nub).map head.group $ "44999911" -> True.

Noktasız sürüm:

f x = q == nub q                -- True if q equals q with duplicates removed
  where
  q = map head $ group x        -- group identical digits and take the first
                                -- e.g. "44999911" -> ["44","9999","11"] -> "491"
                                -- e.g  "3443311" -> ["3","44","33","11"] -> "3431"

3

J, 8 bayt

-:]/:i.~

Şununla test et J.Js sınayın .

Nasıl çalışır

-:]/:i.~  Monadic verb. Argument: y (list of digits)

     i.~  Find the index in y of each d in y.
  ]/:     Sort y by the indices.
-:        Match; compare the reordering with the original y.

1
:] :i :-1
Hesap MakinesiFeline

11
Şaka veya golf önerisi olup olmadığından emin değilim ...
Dennis

3

Python, 56 55 bayt

a=lambda s:~(s[0]in s.lstrip(s[0]))&a(s[1:])if s else 1

Python 3.4.1 ( int not subscriptable) 'de başarısız
CalculatorFeline

Ekstra bir bayt ile kaydedildi ~(kelimenin tam anlamıyla eşdeğerde 1-):a=lambda s:~(s[0]in s.lstrip(s[0]))&a(s[1:])if s else 1
CalculatorFeline

3

C #, 119 bayt

bool m(String s){for(int i=0;i<9;i++){if(new Regex(i.ToString()+"+").Matches(s).Count>1){return false;}}return true;}

Ungolfed

bool m(String s) {
    for(int i=0;i<9;i++) {
        if(new Regex(i.ToString() + "+").Matches(s).Count > 1) {
            return false;
        }
    }

    return true;
}

1
PPCG'ye Hoşgeldiniz! Bir gönderiyi silmek ve sabit sürümle yeni bir gönderi yapmak yerine, eski postanızı da düzenleyebilir ve sonra geri alabilirsiniz. (Bunu yapmaya gerek yok, zaten zaten iki yazı var, ama gelecekte öğrenebilmen için.)
Martin Ender

Benim hatam. Bu Kurallar Golfüne ilk olarak katılmayı düşündüğümde, hedefi yanlış anladım ve başka bir çözüm yapmak için fazla zamanım olmadı (ve kendimi bilerek, daha önce yayınlanan çözümü düzeltmeye çalışmadım). Ama daha sonra biraz daha zamanım olduğu ve "doğru çözümü" göndermeye çalıştığımı söyledi. Söylediklerini yapmayı bile düşünmedim. Bir dahaki sefere aklımda olacak!
auhmaan

Hiç sorun değil, umarım toplulukta iyi vakit geçirirsiniz. :)
Martin Ender

2

Julia, 35 bayt

s->issorted(s,by=x->findfirst(s,x))

Her ne sebeple olursa olsun, sortbir ip issortedalmaz , ama ...


... Dizeleri Julia'da Python gibi değişmez diziler değil mi? Bu beni gerçekten üzecek.
kedi

1
Evet, dizeler değişmez. Muhtemelen bu yüzden issortedçalışıyor, ama sortçalışmıyor.
Dennis,

1
Dizeler için tanımlanmış bir sıralama yöntemi yoktur, ancak tek boyutlu dizilerle aynı şekilde işlenirlerse işe yaramazlar çünkü bunlar yerinde bir kopya kopyası uygulayarak sıralanırlar ve dediğiniz gibi, dizeleri değişmez. Sıralama düzenini kontrol etmek için bir problem değildir, çünkü tekrarlanabilirler üzerinde basit bir döngü olarak uygulanır; Sadece biraz trivia. ¯ \ _ (ツ) _ / ¯
Alex A.

@AlexA. Yani çok fazla aslında Python gibi; sortedAradaki fark, Python'un yerleşikinin yinelenebilir argümanını önce değişken bir listeye dönüştürdüğü - işte bu yüzden sorted(string)dizelerin bir listesini döndürür
kedi,

2

Faktör, 22 bayt

[ dup natural-sort = ]

Teneke ne diyor yok. Anonim bir işlev olarak, bunu yapmalısınız callveya a : word ;.


4
bir kedi oyuna bir fare getirdiğinde beni korkutuyor
downrep_nation

@downrep_nation: P
cat

2

Lua, 107 94 85 Bayt

@LeakyNun sayesinde 13 bayt kurtarıldı

En azından Java'yı yeniyor: D. Lua dizeleri manipüle etmekte berbat ama bence yeterince iyi :).

Bu bir komut satırı argümanı olarak girdi alır ve çıkışlar 1truthy durumlar için ve falsefalsy olanlar için. Şimdi çıkış kodunu kullanarak çıktı verir. Truthy için 0 kodundan, falsy için 1 kodundan çık

o=os.exit;(...):gsub("(.)(.+)%1",function(a,b)if 0<#b:gsub(a,"")then o(1)end end)o(0)

Ungolfed

Dikkatli olun, iki sihirli değişken var ..., ilki programın argümanını içeriyor, ikincisi anonim işlevde yerel ve parametrelerini içeriyor

o=os.exit;               -- ; mandatory, else it would exit instantly
(...):gsub("(.)(.+)%1",  -- iterate over each group of the form x.*x and apply an anonymous
  function(a,b)          -- function that takes the captured group as parameters
  if 0<#b:gsub(a,"")     -- if the captured group (.+) contain other character than
  then                   -- the one captured by (.)
    o(1)                 -- exit with falsy
  end
end)
o(0)                     -- exit with truthy, reached only when the string is okay

O izin verilir ise, yerine os.exit()ile i=#0...
Çatlak Nun

1

JavaScript ES6, 71 69 bayt

h=y=>y.match(/(.)\1*/g);x=>h((u=h(x)).sort().join``).length==u.length

Veya eşdeğer olarak:

x=>((u=x.match(r=/(.)\1*/g)).sort().join``).match(r).length==u.length
x=>(h=y=>y.match(/(.)\1*/g))((u=h(x)).sort().join``).length==u.length

Golf devam ediyor.

Test durumlarını doğrulayın

var truthy = `3
51
44999911
123456789
222222222222222222222`.split `
`;
var falsey = `818
8884443334
4545
554553
1234567891`.split `
`;

var Q = x => ((u = x.match(r = /(.)\1*/g)).sort().join ``).match(r).length == u.length;
truthy.concat(falsey).forEach(e => {
  t = document.createTextNode(`${e} => ${Q(e)}`);
  o.appendChild(t);
  o.appendChild(document.createElement("br"));
});
* {
  font-family: Consolas, monospace;
}
<div id=o></div>


1

C # 111 bayt

bool f(string s){for(int i=0;i<s.Length-1;i++)if(s[i]!=s[i+1]&&s.LastIndexOf(s[i])!=i)return 1==2;return true;}

eski strateji 131 bayt

bool s(string i){var f=Regex.Matches(i,@"([0-9])\1{0,}").Cast<Match>().Select(m=>m.Value[0]);return f.Distinct().SequenceEqual(f);}

ilk golf tamam mı sanırım


1

C, 74 73 71 bayt

Tıraş tek @xsot üç bayt sayesinde!

a[99],c,m;main(d){for(;~c;m|=c^d&&a[d=c]++)c=getchar();putchar(48+!m);}

a[99]Perl'in kendi kendini canlandırmasını seviyorum! Oh, bekle ...
kedi

Sanırım bu işe yarıyor:a[99],c,m;main(d){for(;~c;m|=a[d=c]+=c!=d)c=getchar();putchar(48+1/m);}
xsot

@xsot - değiştirerek tıraş tek byte için teşekkür ederiz !--mile 1/m. Hakkında a[d=c]+=c!=d, gcc ile denedim ve değerlendirme sırası nedeniyle bilgisayarımda çalışmadı. Birlikte oynayacak bir derleyici bulmalıyız.
13'te

Oh, az önce ideone test ettim ve iyi çalıştı. Buna ne dersiniz:a[99],c,m;main(d){for(;~c;m|=c^d&&a[d=c]++)c=getchar();putchar(48+!m);}
xsot

1

Haskell, 37 bayt

f l=(==)=<<scanl1 min$(<$>l).(==)<$>l

Luis Mendo'nun MATL cevabıyla aynı yaklaşımı kullanır : her giriş için eşit indeksleyen bir vektör oluşturur ve sonucun azalan düzende sıralandığını kontrol eder.

(<$>l).(==)<$>lkısa versiyonudur [map(==a)l|a<-l]. Fonksiyon (<$>l).(==)alır aiçin map(==a)lüzerine eşleştirilir l.

scanl1 minlyalnızca ltersine sıralanırsa orijinaline eşit olan kümülatif en küçük öğelerini alır . (==)=<<Bu işlemin altında listenin gerçekten değişmez olup olmadığını kontrol eder.


Farklı bir özyinelemeli strateji 40 bayt verdi:

f(a:b:t)=f(b:t)>(elem a t&&a/=b)
f _=1>0

Bu, ilk iki öğenin bitişik bir bloğun parçası olarak eşit olduğu durumlar hariç, ilk öğesinin geri kalan kısmında görünüp görünmediğini görmek için her bir son eki denetler.


1

Raket, 53 bayt

Aptal, basit versiyon.

(λ(s)(let([s(string->list s)])(eq?(sort s char<?)s)))

Ungolfed:

(define (lame-all-together s)
  (let ([s (string->list s)])
    (eq? (sort s char<?) s)))

Raket, 86 bayt

İşte bunu yapmak için daha etkili yöntemler hakkında @ xnor'ın yorumunu yapan versiyon .

(λ(s)(let([s(string->list(regexp-replace#px"(.)\\1+"s"\\1"))])(eq?(sort s char<?)s)))

Ungolfed:

(define (all-together s)
    (let ([s (string->list (regexp-replace #px"(.)\\1+" s "\\1"))])
      (eq? (sort s char<?) s )))

Tamam, bu aslında hesaplamanın ağırlığını sortişlevden işlevine değiştirebilir regexp-replace, ancak ilginç bir çözümdü. Temel olarak, önce yinelenen karakterlerin çalışmalarını kaldırır ( buraya bakın ), sonra kalan uzunluk-1 çalışmalarının sıralı bir şekilde olup olmadığını test eder.


1

Perl 5, 20 bayt

19, artı -peyerine 1 -e.

$_=!/(.)(?!\1).+\1/



0

Japt , 9 bayt

ò¦ mÌ
eUâ

Dene


açıklama

          :Implicit input of string U             :e.g., "8884443334"
ò¦        :Split on inequality                    :["888","444","333","4"]
   mÌ     :Map and return the last digit of each  :["8","4","3","4"]
\n        :Assign to U
  Uâ      :Remove duplicates                      :["8","4","3"]
e         :Test for equality with U               :false
          :Implicit output of result

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.