Étant donné une liste de chiffres 1 à 9, indiquez si chaque chiffre est regroupé en un seul bloc contigu. En d'autres termes, aucun deux du même chiffre n'est séparé par des chiffres différents. C'est OK si un chiffre n'apparaît pas du tout. Le moins d'octets gagne.

Entrée: liste non vide de chiffres de 1 à 9. Il peut s'agir d'un nombre décimal, d'une chaîne, d'une liste ou d'une séquence similaire.

Sortie: une valeur Truthy cohérente si tous les chiffres sont regroupés dans des blocs contigus, et une valeur Falsey cohérente s'ils ne le sont pas.

Vrais cas:

3
51
44999911
123456789
222222222222222222222

Faux cas:

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 octets

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

Cela attend une liste de chiffres ou de chaînes singleton comme argument. Testez-le sur Ideone .

Merci à @xsot d'avoir joué au golf sur 4 octets!

Merci à @immibis d'avoir joué au golf sur 1 octet!

JavaScript (ES6), 27 octets

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

Utilise l'anticipation négative pour rechercher deux chiffres non contigus. S'il existe au moins deux de ces chiffres, ils peuvent être choisis de sorte que le premier chiffre précède un autre chiffre.

05AB1E , 4 octets

Code:

Ô¹ÙQ

Explication:

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

Utilise CP-1252 encodage .

Essayez-le en ligne!

Gelée , 5 octets

ĠIFPỊ

Essayez-le en ligne!

Comment ça marche

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

1 octets grâce à FryAmTheEggman

SIxLQ

Inspiré par la solution Python ici .

Suite de tests

Explication:

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 43 octets

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

Il s'agit d'une fonction qui accepte l'entrée en tant que vecteur de chiffres et renvoie un booléen. Pour l'appeler, affectez-le à une variable.

Pas le plus court mais j'ai pensé que c'était une approche amusante. Nous exécutons la longueur encoder l'entrée et extraire les valeurs. Si la liste de valeurs contient des doublons FALSE, retournez , sinon retournez TRUE.

Vérifiez tous les cas de test en ligne

Économisé 20 octets grâce à MickyT, 3 grâce à Albert Masclans et 5 grâce à mnel!

MATL , 8 octets

t!=tXSP=

La sortie est un tableau contenant uniquement des valeurs pour true, ou un tableau contenant au moins un zéro pour falsey.

Essayez-le en ligne!

Explication

Considérez l'entrée 22331, qui satisfait la condition. Tester si chaque caractère est égal donne le tableau 2D

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

Le résultat final doit être véridique si les lignes de ce tableau (considérées comme atomiques) sont en ordre décroissant (lexicographique) . Pour comparaison, l'entrée 22321donne le tableau

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

dans lequel les lignes ne sont pas triées.

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

Rétine , 17 octets

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

Essayez-le en ligne! (Légèrement modifié pour exécuter tous les cas de test en même temps.)

La première expression régulière correspond aux chiffres qui sont séparés par d'autres chiffres, nous obtenons donc un 0pour les entrées valides et n'importe où entre 1et 9pour les entrées non valides (en raison de la cupidité du .+, nous ne pouvons pas obtenir plus de n-1correspondances pourn différents chiffres).

Pour inverser la véracité du résultat, nous comptons le nombre de 0s, qui est 1pour les entrées valides et 0pour celles invalides.

Java, 161 156 octets

Parce que Java ...

Voler sans vergogne en empruntant l'expression rationnelle à cette réponse parce que j'ai commencé à essayer de le faire avec des tableaux et des manipulations mathématiques, mais cela est devenu horriblement complexe, et l'expression régulière est un outil aussi bon que n'importe lequel pour ce problème.

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

Non golfé:

import java.util.regex.*;

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

Dispose comme une personne Java sensée:

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 octets

{IeMrz8

Suite de tests .

Rubis, 23 octets

Fonction anonyme. Accepte une chaîne. Regex strat.

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

Ventilation des regex

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

!~signifie s'il n'y a aucune correspondance de l'expression rationnelle dans la chaîne, retourne trueet retourne autrement false.

Mathematica, 26 octets

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

MATL, 13 11 octets

u"G@=fd2<vA

Merci à Luis Mendo d' avoir sauvé deux octets!

Essayez-le en ligne!

Explication

        % 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 octets

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

Exemple d'utilisation: ((==)<*>nub).map head.group $ "44999911"->True .

Une version sans point:

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 octets

-:]/:i.~

Testez-le avec J.js .

Comment ça marche

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

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

C #, 119 octets

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

Non golfé

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 octets

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

Pour une raison quelconque, sortne prend pas de chaîne, mais issorted...

Facteur, 22 octets

[ dup natural-sort = ]

Fait ce qu'il dit sur l'étain. En tant que fonction anonymouse, vous devriez le callfaire ou en faire un : word ;.

Lua, 107 94 85 octets

13 octets enregistrés grâce à @LeakyNun

Au moins, il bat Java: D. Lua craint de manipuler les cordes, mais je pense que c'est assez bon :).

Il prend son entrée en tant qu'argument de ligne de commande et sort 1pour les cas véridiques et les cas falsefausses.Sort maintenant en utilisant son code de sortie. Quittez le code 0 pour la vérité et 1 pour la fausse

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

Non golfé

Attention, il y a deux variables magiques appelées ..., la première contient l'argument du programme, la seconde est locale à la fonction anonyme et contient ses paramètres

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 octets

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

Ou é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

Golf en cours.

Vérifier les cas de test

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 octets

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

ancienne stratégie 131 octets

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

premier golf, je pense que je l'ai fait ok

C, 74 73 71 octets

Rasé d' un octet grâce à @xsot!

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

Haskell, 37 octets

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

Utilise la même approche que la réponse MATL de Luis Mendo : crée un vecteur pour chaque entrée qui les indexe égal et vérifie que le résultat est trié par ordre décroissant.

(<$>l).(==)<$>lest une version plus courte de [map(==a)l|a<-l]. La fonction (<$>l).(==)qui prend aà map(==a)lest mappé sur l.

scanl1 minprend les plus petits éléments cumulatifs de l, ce qui n'est égal à l'original que s'il lest trié en sens inverse. (==)=<<vérifie si la liste est bien invariante sous cette opération.

Une stratégie récursive différente a donné 40 octets:

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

Cela vérifie chaque suffixe pour voir si son premier élément n'apparaît pas dans le reste, excusant les cas où les deux premiers éléments sont égaux dans le cadre d'un bloc contigu.

Raquette, 53 octets

La version stupide et simple.

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

Non golfé:

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

Raquette, 86 octets

Voici la version mettant en œuvre le commentaire de @ xnor sur des moyens plus efficaces de le faire.

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

Non golfé:

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

D'accord, cela peut simplement déplacer le poids du calcul de la sortfonction vers regexp-replace, mais c'était une solution intéressante. En gros, il supprime pistes de caractères en double première ( voir ici ), puis il vérifie si la longueur-1 restantes pistes sont à la mode tri.

Perl 5, 20 octets

19, plus 1 pour -peau lieu de -e.

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

Wolfram Language (Mathematica) , 18 octets

Gather@#==Split@#&

Essayez-le en ligne!

Gatherrassemble une liste en sous-listes d'éléments identiques et Splitdivise une liste en sous-listes d'éléments identiques consécutifs. Ils donnent le même résultat si et seulement si chaque valeur apparaît dans un seul bloc contigu.

Convexe, 17 octets

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

Essayez-le en ligne!

Japt , 9 octets

ò¦ mÌ
eUâ

Essayez-le

Explication

          :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 octets

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

Essayez-le en ligne!