Todos juntos agora

24

Dada uma lista dos dígitos 1 a 9, mostre se cada dígito está agrupado como um único bloco contíguo. Em outras palavras, dois do mesmo dígito não são separados por dígitos diferentes. Tudo bem se um dígito não aparecer. Menos bytes ganha.

Entrada: uma lista não vazia de dígitos de 1 a 9. Pode ser um número decimal, sequência, lista ou sequência semelhante.

Saída: um valor Truthy consistente se todos os dígitos estiverem agrupados em blocos contíguos e um valor Falsey consistente se não estiverem.

Casos verdadeiros:

3
51
44999911
123456789
222222222222222222222

Casos falsos:

818
8884443334
4545
554553
1234567891

Mostrar snippet de código

code-golf  sequence 
— xnor
fonte
2
Uma lista de strings singleton seria um formato de entrada aceitável?
— Dennis
Sim, singletons estão bem.
— Xnor
Alguém pode me dizer qual seria o algoritmo mais eficiente para esse problema? Ou há um problema mais geral em que isso se enquadre e que eu possa procurar?
@ amt528 Você pode fazer isso em tempo linear repetindo cada dígito e verificando se não há execuções anteriores ao primeiro.
— Xnor
Você poderia fornecer um exemplo de como é implementado?

Respostas:

18

Python 3, 38 34 33 bytes

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

Isso espera uma lista de dígitos ou seqüências de caracteres singleton como argumento. Teste em Ideone .

Graças a @xsot por jogar fora 4 bytes!

Obrigado a @immibis por jogar fora um byte!

— Dennis
fonte
Se você tem permissão para aceitar uma lista de strings em vez disso, você pode encurtar issolambda s:s==sorted(s,key=`s`.find)
— xsot
Ah, tentei fazer uma lista, mas não pensei em usar backticks ... vou perguntar ao OP.
— Dennis
Estou faltando alguma coisa - por que você não pode simplesmente usar s.find?
— user253751
@immibis sdeve ser uma lista de strings singleton (ou eu teria que transmitir spara listar para comparação) e list.findnão está definido ...
— Dennis
@Dennis s.indexentão? Parece funcionar para mim.
— user253751
14

JavaScript (ES6), 27 bytes

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

Usa lookahead negativo para procurar por dois dígitos não contíguos. Se pelo menos dois desses dígitos existirem, eles poderão ser escolhidos para que o primeiro dígito anteceda um dígito diferente.

— Neil
fonte
11
Ou, apenas use um regex XD. Isso também funciona.
— Conor O'Brien
11
ahem Retina ahem
— John Dvorak
13

05AB1E , 4 bytes

Código:

Ô¹ÙQ

Explicação:

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

Usos a codificação CP-1252 .

Experimente online!

— Adnan
fonte
2
Você ... acabou de bater geléia ... Eu nunca pensei que isso fosse possível ...
— Bálint
11

Gelatina , 5 bytes

ĠIFPỊ

Experimente online!

Como funciona

Ġ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.
— Dennis
fonte
Cinco bytes que você diz? Que tipo de codificação é essa?
— John Dvorak
4
O Jelly possui sua própria página de códigos , que codifica cada um dos 256 caracteres que entende como um único byte.
— Dennis
9

Pitão, 6 5 bytes

1 bytes graças a FryAmTheEggman

SIxLQ

Inspirado pela solução Python aqui .

Suíte de teste

Explicação:

SIxLQ
  xLQ   Map each element in the input to its index in the input. Input is implicit.
SI      Check whether this list is sorted.
— isaacg
fonte
3
SIxLQparece funcionar.
— FryAmTheEggman 12/04
Isso é genialidade.
— Maltysen
11
O segundo Qnão parece ser analisado corretamente, troca a ordem dos argumentos ou algo assim, assim você obtém todos os 0se sempre é verdadeiro. Aqui está uma suíte de testes.
— FryAmTheEggman 12/04
8

R, 66 48 46 43 38 bytes

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

Esta é uma função que aceita a entrada como um vetor de dígitos e retorna um booleano. Para chamá-lo, atribua-o a uma variável.

Não é o mais curto, mas achei que era uma abordagem divertida. Executamos o comprimento codificar a entrada e extrair os valores. Se a lista de valores contiver duplicatas, retorne FALSE; caso contrário, retorne TRUE.

Verifique todos os casos de teste online

Economizou 20 bytes graças a MickyT, 3 graças a Albert Masclans e 5 graças a mnel!

— Alex A.
fonte
7

MATL , 8 bytes

t!=tXSP=

A saída é uma matriz que contém apenas unidades para verdade ou uma matriz que contém pelo menos um zero para falsey.

Experimente online!

Explicação

Considere a entrada 22331, que satisfaz a condição. Testar se cada caractere é igual ao outro fornece a matriz 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

O resultado final deve ser verdadeiro se as linhas dessa matriz (consideradas atômicas) estiverem em ordem decrescente (lexicográfica) . Para comparação, a entrada 22321fornece a matriz

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

em que as linhas não são classificadas.

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
— Luis Mendo
fonte
5

Retina , 17 bytes

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

Experimente online!(Ligeiramente modificado para executar todos os casos de teste de uma vez.)

O primeiro regex corresponde a dígitos que são separados por outros dígitos, então obtemos um 0para entradas válidas e em qualquer lugar entre 1e 9para entradas inválidas (devido à ganância do the .+, não podemos obter mais que n-1correspondências para ndígitos diferentes).

Para inverter a veracidade do resultado, contamos o número de 0s, que é 1para entradas válidas e 0para entradas inválidas.

— Martin Ender
fonte
Fiz uma mais curta, mas está perto o suficiente da sua para que seja um comentário. Use AntiGrep em vez de Corresponder e remova a última linha: A`(.)(?!\1).+\1por 15 bytes. Também funciona para várias entradas. Verdade é a entrada, falsidade não é nada. Não se pode simplesmente jogar golfe em Martin em seu próprio idioma. :)
— mbomb007
@ mbomb007 eu acho que realmente considerou que, mas, infelizmente, o desafio pede uma consistente truthy (e Falsas) valor, de modo a imprimir a entrada como truthy não é permitido.
— 22616 Martin Ender
5

Java, 161 156 bytes

Porque Java ...

Descaradamente roubar pedindo o regex de esta resposta , porque eu comecei a tentar fazer isso com matrizes e manipulação matemática, mas ficou terrivelmente complexa, e regex é tão bom uma ferramenta como qualquer para este problema.

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

Estabelecido como uma pessoa sensata em 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());
    }
}
— JamesENL
fonte
3
like a sensible Java personIsso seria, nunca usando Java.
— gato
Outras soluções estão apenas fornecendo uma função, a tornariam muito mais curta. Algo comos->s.match("(.)(?!\\1).*\\1")
— Andreas
2
Mas então não podíamos nos deleitar com a verbosidade da resposta.
— JamesENL
4

Ruby, 23 bytes

Função anônima. Aceita uma string. Regex strat.

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

Repartição de 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

!~significa que, se não houver correspondências da expressão regular na cadeia, retorne truee retorne false.

— Value Ink
fonte
4

Mathematica, 26 bytes

0<##&@@Sort[#&@@@Split@#]&
— feersum
fonte
4

MATL, 13 11 bytes

u"G@=fd2<vA

Obrigado a Luis Mendo por salvar dois bytes!

Experimente Online!

Explicação

        % 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
— Suever
fonte
Você pode pegar a entrada entre aspas (permitida por padrão) e remover j. Além disso, eu acho que você pode mover-se vAdentro do circuito e remova]
— Luis Mendo
@LuisMendo Thanks! Eu tinha mexido em colocar Y&dentro, mas isso não funcionou porque fd2<pode estar vazio. Mover-se para vAdentro funciona muito bem! Também gostaria que tivéssemos um estábulo uniqueque não ocupasse toneladas de bytes.
— Suever 12/04/16
Agora, o unique stable leva um pouco menos, usando um número em vez da string predefinida. No entanto, posso adicionar uma versão mais curta no futuro. Ou apenas torne uestável por padrão (você sempre pode incluir Sdepois, dois bytes). O que você acha?
— Luis Mendo
3

Haskell, 44 bytes

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

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

Uma versão sem ponto:

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"
— nimi
fonte
3

J, 8 bytes

-:]/:i.~

Testá-lo com J.js .

Como funciona

-:]/: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.
— Dennis
fonte
11
:] :i :-1
— CalculatorFeline
11
Não tenho certeza se piada ou golfe sugestão ...
— Dennis
3

Python, 56 55 bytes

a=lambda s:~(s[0]in s.lstrip(s[0]))&a(s[1:])if s else 1
— orlp
fonte
Falha no Python 3.4.1 ( int not subscriptable)
— CalculadoraAbr
Salvo um byte extra com ~(literalmente, que é equivalente a 1-):a=lambda s:~(s[0]in s.lstrip(s[0]))&a(s[1:])if s else 1
— CalculatorFeline
3

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;
}
— auhmaan
fonte
11
Bem-vindo ao PPCG! Em vez de excluir uma postagem e criar uma nova postagem com a versão fixa, você também pode editar sua postagem antiga e excluí-la. (Não há necessidade de fazer isso agora que há dois lugares já de qualquer maneira, mas só para você saber no futuro.)
— Martin Ender
Minha culpa. Quando pretendi participar deste Code Golf, interpretei errado o objetivo e não tive muito tempo para fazer outra solução (e, sabendo de mim mesmo, não tentaria corrigir a solução postada anteriormente). Mas me disseram que eu tinha mais tempo livre e tentei postar a "solução correta". Nem sequer pensou em fazer o que você disse. Da próxima vez vou ter isso em mente!
— Auhmaan
Sem problemas, espero que você se divirta na comunidade. :)
— Martin Ender
2

Julia, 35 bytes

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

Por qualquer motivo, sortnão pega uma string, mas issorted...

— Dennis
fonte
... As strings não são matrizes imutáveis ​​em Julia como Python? Isso me deixaria muito triste.
— gato
11
Sim, cordas são imutáveis. Provavelmente é por isso que issortedfunciona, mas sortnão funciona.
— 216 Dennis
11
Não há um método de classificação definido para seqüências de caracteres, mas não funcionaria se elas fossem processadas da mesma maneira que as matrizes unidimensionais, porque elas são classificadas pela execução de uma cópia no local e, como você disse, cordas são imutáveis. Não é um problema para verificar a ordem classificada, porque é implementado como um loop simples sobre um iterável, o que é bom para strings. Apenas algumas curiosidades. ### (#) _ / ¯
— Alex A.
@AlexA. Então, muito parecido com Python na verdade; a diferença é que builtin do Python sortedtransforma seu argumento iterable em uma lista mutável primeira - é por isso que sorted(string)retorna uma lista de strings
— cat
2

Fator, 22 bytes

[ dup natural-sort = ]

Faz o que diz na lata. Como função anônima, você deve callfazer isso ou torná-lo um : word ;.

— gato
fonte
4
isso me assusta quando um gato coloca um mouse no jogo
— downrep_nation
@downrep_nation: P
— cat
2

Lua, 107 94 85 bytes

13 bytes salvos graças a @LeakyNun

Pelo menos, ele vence o Java: D. Lua é péssima em manipular strings, mas acho que é bom o suficiente :).

Ele recebe sua entrada como argumento da linha de comando e produz 1para casos falseverdadeiros e para casos falsos. Agora sai usando seu código de saída. Código de saída 0 para verdade e 1 para falsidade

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

Ungolfed

Cuidado, existem duas variáveis ​​mágicas chamadas ..., a primeira contém o argumento do programa, a segunda é local para a função anônima e contém seus parâmetros

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
— Katenkyo
fonte
Se for permitido, você pode substituir os.exit()com i=#0...
— Leaky Nun
1

JavaScript ES6, 71 69 bytes

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

Ou equivalente:

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

Golfe em andamento.

Verificar casos de teste

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>
Expandir snippet

— Conor O'Brien
fonte
1

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

estratégia antiga 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);}

primeiro golfe eu acho que fiz ok em

— downrep_nation
fonte
1

C, 74 73 71 bytes

Raspada uma de três bytes, graças ao @xsot!

a[99],c,m;main(d){for(;~c;m|=c^d&&a[d=c]++)c=getchar();putchar(48+!m);}
— mIllIbyte
fonte
a[99]Eu amo a autovivificação do Perl! Oh, espera ...
— cat
Eu acho que isso funciona:a[99],c,m;main(d){for(;~c;m|=a[d=c]+=c!=d)c=getchar();putchar(48+1/m);}
— xsot 14/04
@xsot - Obrigado por remover um byte substituindo !--mpor 1/m. Sobre a[d=c]+=c!=d, tentei com o gcc e não funcionou no meu computador por causa da ordem da avaliação. Precisamos encontrar um compilador que funcione junto.
— MIllIbyte
Oh, eu apenas testei em ideone e funcionou bem. Como sobre isso:a[99],c,m;main(d){for(;~c;m|=c^d&&a[d=c]++)c=getchar();putchar(48+!m);}
— xsot 14/04
1

Haskell, 37 bytes

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

Usa a mesma abordagem da resposta MATL de Luis Mendo : cria um vetor para cada entrada com índices iguais a ele e verifica se o resultado é classificado em ordem decrescente.

(<$>l).(==)<$>lé a versão mais curta do [map(==a)l|a<-l]. A função (<$>l).(==)que leva apara map(==a)lé mapeada paral .

scanl1 minpega os menores elementos cumulativos de l, que só lé igual ao original se tiver classificação inversa.(==)=<<verifica se a lista é realmente invariável nesta operação.

Uma estratégia recursiva diferente forneceu 40 bytes:

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

Isso verifica cada sufixo para ver se o primeiro elemento não aparece no restante, desculpando os casos em que os dois primeiros elementos são iguais como parte de um bloco contíguo.

— xnor
fonte
1

Raquete, 53 bytes

A versão simples e burra.

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

Raquete, 86 bytes

Aqui está a versão que implementa o comentário do @ xnor sobre maneiras mais eficientes de fazer isso.

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

Tudo bem, isso pode apenas mudar o peso da computação da sortfunção para regexp-replace, mas foi uma solução interessante. Basicamente, ele remove as execuções de caracteres duplicados primeiro ( veja aqui ) e testa se as execuções de comprimento 1 restantes estão ordenadas.

— gato
fonte
1

Perl 5, 20 bytes

19, mais 1 para em -pevez de -e.

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

Wolfram Language (Mathematica) , 18 bytes

Gather@#==Split@#&

Experimente online!

Gatherreúne uma lista em sublistas de elementos idênticos e Splitdivide uma lista em sublistas de elementos idênticos consecutivos. Eles fornecem o mesmo resultado se e somente se cada valor aparecer em apenas um bloco contíguo.

— Misha Lavrov
fonte
0

Japonês , 9 bytes

ò¦ mÌ
eUâ

Tente

Explicação

          :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
— Shaggy
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.