Учитывая список цифр от 1 до 9, выведите, сгруппирована ли каждая цифра как один непрерывный блок. Другими словами, нет двух одинаковых цифр, разделенных разными цифрами. Это нормально, если цифра не появляется вообще. Побеждает несколько байтов.

Ввод: непустой список цифр от 1 до 9. Это может быть десятичное число, строка, список или аналогичная последовательность.

Вывод: непротиворечивое значение Truthy, если все цифры сгруппированы в смежные блоки, и непротиворечивое значение Falsey, если это не так.

Истинные случаи:

3
51
44999911
123456789
222222222222222222222

Ложные случаи:

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 байта

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

Это ожидает список цифр или одиночных строк в качестве аргумента. Проверьте это на Ideone .

Спасибо @xsot за 4 байта!

Спасибо @immibis за удаление 1 байта!

JavaScript (ES6), 27 байт

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

Использует отрицательный прогноз для поиска двух несмежных цифр. Если существует хотя бы две такие цифры, то их можно выбрать так, чтобы первая цифра предшествовала другой цифре.

05AB1E , 4 байта

Код:

Ô¹ÙQ

Объяснение:

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

Попробуйте онлайн!

Желе , 5 байт

ĠIFPỊ

Попробуйте онлайн!

Как это работает

Ġ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 байт

1 байт благодаря FryAmTheEggman

SIxLQ

Вдохновленный решением Python здесь .

Тестирование

Объяснение:

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 байт

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

Это функция, которая принимает входные данные как вектор цифр и возвращает логическое значение. Чтобы вызвать его, назначьте его переменной.

Не самый короткий, но я думал, что это был забавный подход. Мы запускаем length, кодируем ввод и извлекаем значения. Если список значений содержит дубликаты, вернуть FALSE, в противном случае вернуть TRUE.

Проверьте все тестовые примеры онлайн

Благодаря MickyT сэкономлено 20 байт, 3 благодаря Albert Masclans и 5 благодаря mnel!

MATL , 8 байт

t!=tXSP=

Выходные данные - это массив, содержащий только единицы для истинности, или массив, содержащий хотя бы один ноль для Falsey.

Попробуйте онлайн!

объяснение

Рассмотрим вход 22331, который удовлетворяет условию. Проверка того, что каждый символ равен друг другу, дает двумерный массив

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

Окончательный результат должен быть достоверным, если строки этого массива (считаются атомарными) имеют (лексикографический) убывающий порядок . Для сравнения ввод 22321дает массив

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

в котором строки не отсортированы.

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

Сетчатка , 17 байт

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

Попробуйте онлайн! (Немного изменен для запуска всех тестовых случаев одновременно.)

Первые матчи регулярного выражения цифра , которые будут разделены другими цифрами, поэтому мы получаем 0для действительных входов и в любом месте между 1и 9недействительные входы (из - за алчности из .+, мы не можем получить больше , чем n-1спичек для nразличных цифр).

Чтобы инвертировать достоверность результата, мы рассчитываем число 0s, которое предназначено 1для действительных и 0недействительных входных данных .

Java, 161 156 байт

Потому что Java ...

Бесстыдно крадя заимствуя регулярное выражение из этого ответа, потому что я начал пытаться делать это с массивами и математическими манипуляциями, но это стало ужасно сложным, и регулярное выражение - такой же хороший инструмент, как и любой другой, для решения этой проблемы.

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

Выложил как разумный Java человек:

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 байт

{IeMrz8

Тестовый пакет .

Рубин, 23 байта

Анонимная функция. Принимает строку. Regex strat.

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

Распределение регулярных выражений

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

!~означает, что если в строке нет совпадений с регулярным выражением, return trueи иначе return false.

Mathematica, 26 байтов

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

MATL, 13 11 байт

u"G@=fd2<vA

Спасибо Луису Мендо за сохранение двух байтов!

Попробуйте онлайн!

объяснение

        % 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 байта

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

Пример использования: ((==)<*>nub).map head.group $ "44999911"-> True.

Неточечная версия:

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 байт

-:]/:i.~

Проверьте это с J.js .

Как это работает

-:]/: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 байт

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

C #, 119 байт

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

Юлия, 35 байт

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

По какой-то причине sortне принимает строку, но issortedделает ...

Фактор, 22 байта

[ dup natural-sort = ]

Делает то, что говорит на банке. Как анонимная функция, вы должны callсделать это или сделать это : word ;.

Луа, 107 94 85 байт

13 байтов сохранено благодаря @LeakyNun

По крайней мере, это лучше, чем Java. Луа сосет при манипулировании струнами, но я думаю, что это достаточно хорошо :).

Он принимает входные данные в качестве аргумента командной строки и выводит их 1для истинных и ложных случаев false. Теперь выводит используя свой код выхода. Код выхода 0 для правдивых и 1 для ложных

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

Ungolfed

Будьте внимательны, есть две магические переменные ..., первая из которых содержит аргумент программы, вторая является локальной для анонимной функции и содержит ее параметры

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 байт

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

Или, что эквивалентно:

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

Гольф в прогрессе.

Проверьте контрольные примеры

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 байт

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

старая стратегия 131 байт

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

первый гольф, я думаю, что я хорошо в

С 74 73 71 байт

Побрил один три байта благодаря @xsot!

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

Haskell, 37 байт

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

Использует тот же подход, что и ответ MATL Луиса Мендо : создает вектор для каждой записи, индексы которого равны ему, и проверяет, что результат отсортирован в порядке убывания.

(<$>l).(==)<$>lэто более короткая версия [map(==a)l|a<-l]. Функция , (<$>l).(==)которая принимает aк map(==a)lотображается на l.

scanl1 minпринимает кумулятивные наименьшие элементы l, которые равны оригиналу, только если lобратная сортировка. (==)=<<проверяет, действительно ли список инвариантен для этой операции.

Другая рекурсивная стратегия дала 40 байтов:

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

Это проверяет каждый суффикс, чтобы видеть, не появляется ли его первый элемент в оставшейся части, исключая случаи, когда первые два элемента равны как часть непрерывного блока.

Ракетка, 53 байта

Тупая, простая версия.

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

Ракетка, 86 байт

Вот версия, реализующая комментарий @ xnor о более эффективных способах сделать это.

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

Ладно, это может на самом деле просто перенести вес вычислений с sortфункции на regexp-replace, но это было интересное решение. По сути, сначала он удаляет повторяющиеся символы ( см. Здесь ), а затем проверяет, отсортированы ли оставшиеся серии длины 1.

Perl 5, 20 байт

19, плюс 1 -peвместо -e.

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

Wolfram Language (Mathematica) , 18 байт

Gather@#==Split@#&

Попробуйте онлайн!

Gatherсобирает список в подсписки идентичных элементов и Splitразбивает список на подсписки последовательных идентичных элементов. Они дают тот же результат, если и только если каждое значение появляется только в одном непрерывном блоке.

Выпуклый, 17 байт

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

Попробуйте онлайн!

Japt , 9 байт

ò¦ mÌ
eUâ

Попытайся

объяснение

          :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 байт

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

Попробуйте онлайн!