Bei einer gegebenen Liste der Ziffern 1 bis 9 wird ausgegeben, ob jede Ziffer zu einem einzigen zusammenhängenden Block zusammengefasst ist. Mit anderen Worten, keine zwei gleichen Ziffern werden durch verschiedene Ziffern getrennt. Es ist in Ordnung, wenn eine Ziffer überhaupt nicht angezeigt wird. Wenigste Bytes gewinnt.

Eingang: Eine nicht leere Liste mit den Ziffern 1 bis 9. Dies kann eine Dezimalzahl, eine Zeichenfolge, eine Liste oder eine ähnliche Folge sein.

Ausgabe: Ein konsistenter Wahrheitswert , wenn alle Ziffern in zusammenhängenden Blöcken gruppiert sind, und ein konsistenter Falsey- Wert, wenn dies nicht der Fall ist .

Wahre Fälle:

3
51
44999911
123456789
222222222222222222222

Falsche Fälle:

818
8884443334
4545
554553
1234567891

var QUESTION_ID=77608,OVERRIDE_USER=20260;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/77608/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Python 3, 38 34 33 Bytes

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

Dies erwartet eine Liste von Ziffern oder Singleton-Strings als Argument. Teste es auf Ideone .

Vielen Dank an @xsot für das Golfen mit 4 Bytes!

Vielen Dank an @immibis für das Golfen ab 1 Byte!

JavaScript (ES6), 27 Byte

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

Verwendet den negativen Lookahead, um nach zwei nicht zusammenhängenden Ziffern zu suchen. Wenn mindestens zwei solcher Ziffern vorhanden sind, können sie so gewählt werden, dass die erste Ziffer einer anderen Ziffer vorangeht.

05AB1E , 4 Bytes

Code:

Ô¹ÙQ

Erläuterung:

Ô     # 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.

Verwendet CP-1252- Codierung.

Probieren Sie es online!

Gelee , 5 Bytes

ĠIFPỊ

Probieren Sie es online!

Wie es funktioniert

Ġ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.

Pyth, 6 5 Bytes

1 Byte dank FryAmTheEggman

SIxLQ

Inspiriert von der Python-Lösung hier .

Testsuite

Erläuterung:

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

R 66 48 46 43 38 Bytes

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

Dies ist eine Funktion, die die Eingabe als Vektor von Ziffern akzeptiert und einen Booleschen Wert zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu.

Nicht die kürzeste, aber ich dachte, es wäre ein lustiger Ansatz. Wir führen eine Längencodierung der Eingabe durch und extrahieren die Werte. Wenn die Werteliste Duplikate enthält, kehren Sie zurück FALSE, andernfalls zurück TRUE.

Überprüfen Sie alle Testfälle online

Dank MickyT 20 Bytes gespart, dank Albert Masclans 3 und dank mnel 5!

MATL , 8 Bytes

t!=tXSP=

Die Ausgabe ist ein Array, das nur Einsen für die Wahrheit enthält, oder ein Array, das mindestens eine Null für die Falschheit enthält.

Probieren Sie es online!

Erläuterung

Betrachten Sie die Eingabe 22331, die die Bedingung erfüllt. Das Testen, ob jedes Zeichen gleich ist, ergibt das 2D-Array

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

Das Endergebnis sollte wahr sein, wenn die Zeilen dieses Arrays (als atomar betrachtet) in absteigender (lexikografischer) Reihenfolge vorliegen . Zum Vergleich 22321liefert die Eingabe das Array

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

in denen die Zeilen nicht sortiert sind.

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

Retina , 17 Bytes

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

Probieren Sie es online! (Leicht modifiziert, um alle Testfälle gleichzeitig auszuführen.)

Die ersten Regex -Übereinstimmungen Ziffern , die sich von anderen Stellen getrennt, so dass wir eine bekommen 0für gültige Eingaben und irgendwo zwischen 1und 9für ungültige Eingaben (aufgrund der Gefräßigkeit der das .+können wir nicht mehr als bekommen n-1Treffer für nverschiedene Stellen).

Um die Richtigkeit des Ergebnisses umzukehren, wird die Anzahl von 0s gezählt, die 1für gültige Eingaben und 0für ungültige Eingaben gilt .

Java, 161 156 Bytes

Weil Java ...

Schamlos zu stehlen , den Regex aus dieser Antwort auszuleihen, weil ich zu Beginn versucht habe, dies mit Arrays und mathematischen Manipulationen zu tun, aber es wurde schrecklich komplex, und Regex ist für dieses Problem ein ebenso gutes Werkzeug wie jedes andere.

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());
    }

Ausgelegt wie eine vernünftige Java-Person:

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());
    }
}

Pyth, 7 Bytes

{IeMrz8

Test Suite .

Ruby, 23 Bytes

Anonyme Funktion. Akzeptiert eine Zeichenfolge. Regex Strat.

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

Regex-Panne

/(.)(?!\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

!~bedeutet, wenn die Zeichenfolge keine Übereinstimmungen mit dem regulären Ausdruck enthält, return trueund andernfalls return false.

Mathematica, 26 Bytes

0<##&@@Sort[#&@@@Split@#]&

MATL, 13 11 Bytes

u"G@=fd2<vA

Danke an Luis Mendo für das Speichern von zwei Bytes!

Probieren Sie es online!

Erläuterung

        % 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

Haskell, 44 Bytes

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

Anwendungsbeispiel: ((==)<*>nub).map head.group $ "44999911"-> True.

Eine nicht pointfree Version:

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"

J, 8 Bytes

-:]/:i.~

Testen Sie es mit J.js .

Wie es funktioniert

-:]/: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.

Python, 56-55 Bytes

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

C #, 119 Bytes

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;
}

Julia, 35 Bytes

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

Aus welchem ​​Grund auch immer, sortnimmt keine Zeichenfolge, issortedtut aber ...

Faktor 22 Bytes

[ dup natural-sort = ]

Tut was es verspricht. Als anonyme Funktion sollten Sie calldies tun oder es zu einer machen : word ;.

Lua, 107 94 85 Bytes

Dank @LeakyNun 13 Bytes gespart

Zumindest schlägt es Java: D. Lua hat Spaß daran, Saiten zu manipulieren, aber ich denke, es ist gut genug :).

Es nimmt seine Eingabe als Befehlszeilenargument und gibt sie 1für wahrheitsgemäße und falsefür falsch aus. Jetzt wird mit seinem Exit-Code ausgegeben. Beenden Sie den Code 0 für "Wahr" und 1 für "Falsch"

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

Ungolfed

Seien Sie vorsichtig, es gibt zwei Magic-Variablen ..., die aufgerufen werden. Die erste enthält das Argument des Programms, die zweite ist lokal für die anonyme Funktion und enthält ihre Parameter

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

JavaScript ES6, 71 69 Bytes

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

Oder äquivalent:

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

Golfen im Gange.

Überprüfen Sie die Testfälle

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>

C # 111 Bytes

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;}

alte Strategie 131 Bytes

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);}

Ich glaube, ich habe das erste Mal gut gespielt

C 74, 73 71 Bytes

Rasiert ein Drei-Byte dank @xsot!

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

Haskell, 37 Bytes

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

Verwendet den gleichen Ansatz wie die MATL-Antwort von Luis Mendo : für jeden Eintrag einen Vektor, dessen Indizes diesem entsprechen, und überprüft, ob das Ergebnis in absteigender Reihenfolge sortiert ist.

(<$>l).(==)<$>list eine kürzere Version von [map(==a)l|a<-l]. Die Funktion , (<$>l).(==)die nimmt azu map(==a)lwird gemapptl .

scanl1 minNimmt die kumulativ kleinsten Elemente von auf l, was dem Original nur entspricht, wenn les rücksortiert ist.(==)=<<prüft, ob die Liste bei dieser Operation tatsächlich unveränderlich ist.

Eine andere rekursive Strategie ergab 40 Bytes:

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

Dadurch wird jedes Suffix überprüft, um festzustellen, ob sein erstes Element im Rest nicht erscheint. Dies entschuldigt Fälle, in denen die ersten beiden Elemente als Teil eines zusammenhängenden Blocks gleich sind.

Schläger, 53 Bytes

Die dumme, einfache Version.

(λ(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)))

Schläger, 86 Bytes

Hier ist die Version, die den Kommentar von @ xnor zu effizienteren Methoden implementiert .

(λ(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 )))

Okay, dies kann das Gewicht der Berechnung tatsächlich von der sortFunktion auf verschieben regexp-replace, aber es war eine interessante Lösung. Im Grunde ist es entfernt Läufe von doppelten Zeichen zuerst ( siehe hier ), prüft dann , ob die verbleibende Länge-1 läuft in sortierter Art und Weise ist.

Perl 5, 20 Bytes

19, plus 1 für -pestatt -e.

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

Wolfram Language (Mathematica) , 18 Byte

Gather@#==Split@#&

Probieren Sie es online!

Gathersammelt eine Liste in Unterlisten identischer Elemente und Splitteilt sie in Unterlisten aufeinanderfolgender identischer Elemente auf. Sie liefern genau dann das gleiche Ergebnis, wenn jeder Wert nur in einem zusammenhängenden Block vorkommt.

Konvex, 17 Bytes

9´\f{\s'++\ð½¬}ª!

Probieren Sie es online!

Japt , 9 Bytes

ò¦ mÌ
eUâ

Versuch es

Erläuterung

          :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

APL (Dyalog) , 17 Bytes

(⍋≡⍳∘≢)∘⌽∘∊2⊥∘.=⍨

Probieren Sie es online!