Todos juntos ahora

24

Dada una lista de dígitos del 1 al 9, muestra si cada dígito está agrupado como un solo bloque contiguo. En otras palabras, no hay dos del mismo dígito separados por dígitos diferentes. Está bien si un dígito no aparece en absoluto. Pocos bytes ganan.

Entrada: una lista no vacía de dígitos del 1 al 9. Esto puede ser como un número decimal, cadena, lista o secuencia similar.

Salida: un valor de Verdad consistente si todos los dígitos están agrupados en bloques contiguos, y un valor de Falsey consistente si no lo están.

Casos verdaderos:

3
51
44999911
123456789
222222222222222222222

Casos falsos:

818
8884443334
4545
554553
1234567891

Mostrar fragmento de código

code-golf sequence xnor
fuente
2
¿Sería una lista de cadenas singleton un formato de entrada aceptable?
Dennis
Sí, los singletons están bien.
xnor
¿Alguien puede decirme cuál sería el algoritmo más eficiente para este problema? ¿O hay un problema más general en el que esto se encuentra y que puedo buscar?
@ amt528 Puede hacerlo en tiempo lineal iterando sobre cada dígito y verificando que no haya pasadas del primero.
xnor
¿Podría dar un ejemplo de cómo se implementa?

Respuestas:

18

Python 3, 38 34 33 bytes

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

Esto espera una lista de dígitos o cadenas singleton como argumento. Pruébalo en Ideone .

¡Gracias a @xsot por jugar golf 4 bytes!

¡Gracias a @immibis por jugar golf en 1 byte!

Dennis
fuente
Si se le permite aceptar una lista de cadenas en su lugar, se puede acortar este alambda s:s==sorted(s,key=`s`.find)
xsot
Ah, intenté tomar una lista, pero no pensé en usar backticks ... Le preguntaré al OP.
Dennis
Me estoy perdiendo algo, ¿por qué no puedes usarlo s.find?
user253751
@immibis stiene que ser una lista de cadenas singleton (o tendría que emitir spara enumerar para la comparación), y list.findno está definido ...
Dennis
@Dennis s.indexentonces? Parece funcionar para mi.
user253751
14

JavaScript (ES6), 27 bytes

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

Utiliza anticipación negativa para buscar dos dígitos no contiguos. Si existen al menos dos de esos dígitos, entonces se pueden elegir para que el primer dígito preceda a un dígito diferente.

Neil
fuente
1
O simplemente use una expresión regular XD. Eso tambien funciona.
Conor O'Brien
1
ejem Retina ejem
John Dvorak
13

05AB1E , 4 bytes

Código:

Ô¹ÙQ

Explicación:

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

Utiliza la codificación CP-1252 .

Pruébalo en línea!

Adnan
fuente
2
Tú ... simplemente venciste a Jelly ... Nunca pensé que esto fuera posible ...
Bálint
11

Jalea , 5 bytes

ĠIFPỊ

Pruébalo en línea!

Cómo 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
fuente
¿Cinco bytes que dices? ¿Qué tipo de codificación es esa?
John Dvorak
44
Jelly tiene su propia página de códigos , que codifica cada uno de los 256 caracteres que entiende como un solo byte.
Dennis
9

Pyth, 6 5 bytes

1 bytes gracias a FryAmTheEggman

SIxLQ

Inspirado por la solución Python aquí .

Banco de pruebas

Explicación:

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
fuente
3
SIxLQparece funcionar.
FryAmTheEggman
Esto es genial.
Maltysen
1
El segundo Qno parece ser analizado correctamente, intercambia el orden de los argumentos o algo así para obtener todo 0sy siempre da verdad. Aquí hay un conjunto de pruebas.
FryAmTheEggman
8

R, 66 48 46 43 38 bytes

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

Esta es una función que acepta la entrada como un vector de dígitos y devuelve un valor booleano. Para llamarlo, asígnelo a una variable.

No es el más corto, pero pensé que era un enfoque divertido. Corremos longitud codificar la entrada y extraer los valores. Si la lista de valores contiene duplicados, devuelva FALSE, de lo contrario, devuelva TRUE.

Verifique todos los casos de prueba en línea

¡Ahorré 20 bytes gracias a MickyT, 3 gracias a Albert Masclans y 5 gracias a mnel!

Alex A.
fuente
7

MATL , 8 bytes

t!=tXSP=

La salida es una matriz que contiene solo unos para la verdad, o una matriz que contiene al menos un cero para falsey.

Pruébalo en línea!

Explicación

Considere la entrada 22331, que satisface la condición. La prueba de si cada personaje es igual entre sí da la 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

El resultado final debe ser verdadero si las filas de esa matriz (consideradas como atómicas) están en orden decreciente (lexicográfico) . A modo de comparación, la entrada 22321da la 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

en el que las filas no están ordenadas.

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
fuente
5

Retina , 17 bytes

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

Pruébalo en línea! (Ligeramente modificado para ejecutar todos los casos de prueba a la vez).

La primera expresión regular coincide con los dígitos que están separados por otros dígitos, por lo que obtenemos una 0para entradas válidas y en cualquier lugar entre 1y 9para entradas no válidas (debido a la codicia de la .+, no podemos obtener más que n-1coincidencias para ndiferentes dígitos).

Para invertir la veracidad del resultado, contamos el número de 0s, que es 1para entradas válidas y 0para entradas no válidas.

Martin Ender
fuente
Hice uno más corto, pero está lo suficientemente cerca del tuyo como para que sea un comentario. Use AntiGrep en lugar de Match, luego elimine la última línea: A`(.)(?!\1).+\1por 15 bytes. También funciona para múltiples entradas. La verdad es la entrada, la falsedad no es nada. Uno no simplemente supera a Martin en su propio idioma. :)
mbomb007
@ mbomb007 Creo que en realidad consideró que, pero, por desgracia, el desafío pide una constante Truthy (y Falsy) valor, por lo que la impresión de la entrada como no está permitido Truthy.
Martin Ender
5

Java, 161156 bytes

Porque Java ...

Sin vergüenza robando prestada la expresión regular de esta respuesta porque empecé a cabo tratando de hacer esto con los arreglos y la manipulación de las matemáticas, pero se puso terriblemente compleja, y expresiones regulares es tan buena como cualquier herramienta 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());}}

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

Presentado como una persona sensible de 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
fuente
3
like a sensible Java personEso sería, no usar Java nunca.
gato
Otras soluciones solo proporcionan una función, la harían mucho más corta. Algo así comos->s.match("(.)(?!\\1).*\\1")
Andreas
2
Pero entonces no pudimos deleitarnos con la verbosidad de la respuesta.
JamesENL
4

Ruby, 23 bytes

Función anónima. Acepta una cadena. Regex strat.

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

Desglose de expresiones regulares

/(.)(?!\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 si no hay coincidencias de la expresión regular dentro de la cadena, return truey return false.

Tinta de valor
fuente
4

Mathematica, 26 bytes

0<##&@@Sort[#&@@@Split@#]&
Feersum
fuente
4

MATL, 13 11 bytes

u"G@=fd2<vA

¡Gracias a Luis Mendo por guardar dos bytes!

Pruébalo en línea!

Explicación

        % 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
fuente
Puede tomar la entrada con comillas (permitidas por defecto) y eliminar j. Además, creo que puedes moverte vAdentro del ciclo y eliminarlo]
Luis Mendo
@LuisMendo ¡Gracias! Me había tomado la molestia de ponerlo Y&dentro, pero eso no funcionó porque fd2<puede estar vacío. ¡Moverse vAadentro funciona muy bien! También desearía que tuviéramos un establo uniqueque no ocupara toneladas de bytes.
Suever
Ahora estable único toma un poco menos, usando un número en lugar de la cadena predefinida. Sin embargo, puedo agregar una versión más corta en el futuro. O simplemente establezca ude manera predeterminada (siempre puede incluir Sluego dos bytes). ¿Qué piensas?
Luis Mendo
3

Haskell, 44 bytes

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

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

Una versión sin puntos:

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
fuente
3

J, 8 bytes

-:]/:i.~

Pruébalo con J.js .

Cómo 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
fuente
1
:] :i :-1
CalculatorFeline
11
No estoy seguro si broma o sugerencia de golf ...
Dennis
3

Python, 56 55 bytes

a=lambda s:~(s[0]in s.lstrip(s[0]))&a(s[1:])if s else 1
orlp
fuente
Falla en Python 3.4.1 ( int not subscriptable)
CalculatorFeline
Guardado un byte adicional con ~(que literalmente es 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;}

Sin 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;
}
auhmaan
fuente
1
Bienvenido a PPCG! En lugar de eliminar una publicación y hacer una nueva publicación con la versión fija, también puede editar su publicación anterior y luego recuperarla. (No es necesario hacer eso ahora que ya hay dos publicaciones de todos modos, pero para que lo sepas en el futuro.)
Martin Ender
Mi error. Cuando tuve la intención de participar en este Code Golf, leí mal el objetivo y no tuve mucho tiempo para hacer otra solución (y conociendo a mí mismo, no trataría de corregir la solución publicada anteriormente). Pero luego me dijeron que tenía más tiempo libre e intenté publicar la "solución correcta". Ni siquiera pensé en hacer lo que dijiste. ¡La próxima vez lo tendré en mente!
auhmaan
No hay problema en absoluto, espero que lo pases bien en la comunidad. :)
Martin Ender
2

Julia, 35 bytes

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

Por alguna razón, sortno toma una cuerda, pero issortedsí ...

Dennis
fuente
... ¿Las cadenas no son matrices inmutables en Julia como Python? Eso me pondría muy triste.
gato
1
Sí, las cuerdas son inmutables. Probablemente por eso issortedfunciona, pero sortno lo hace.
Dennis
1
No hay un método de clasificación definido para las cadenas, pero no funcionaría si se procesaran de la misma manera que las matrices unidimensionales porque se ordenan realizando una copia in situ y, como usted dijo, Las cuerdas son inmutables. Sin embargo, no es un problema para verificar el orden ordenado porque se implementa como un bucle simple sobre un iterable, lo cual está bien para las cadenas. Solo algunas curiosidades. ¯ \ _ (ツ) _ / ¯
Alex A.
@AlexA. Así que muy mucho como Python, de hecho; la diferencia es que la construcción incorporada de Python sortedconvierte su argumento iterable en una lista mutable primero, es por eso que sorted(string)devuelve una lista de cadenas
cat
2

Factor, 22 bytes

[ dup natural-sort = ]

Hace lo que dice en la lata. Como una función anónima, debe hacer callesto o convertirlo en a : word ;.

gato
fuente
44
me asusta cuando un gato trae un mouse al juego
downrep_nation
@downrep_nation: P
cat
2

Lua, 107 94 85 Bytes

13 bytes guardados gracias a @LeakyNun

Al menos, supera a Java: D. Lua apesta manipulando cadenas, pero creo que es lo suficientemente bueno :).

Toma su entrada como un argumento de línea de comandos, y da salida 1para casos verdaderos y falsepara casos falsos. Ahora sale usando su código de salida. Código de salida 0 para verdad, y 1 para falsedad

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

Sin golf

Tenga cuidado, hay dos variables mágicas llamadas ..., la primera contiene el argumento del programa, la segunda es local para la función anónima y contiene sus 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
fuente
Si está permitido, puede reemplazarlo os.exit()con 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

O 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

Golf en progreso.

Verificar casos de prueba

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 fragmento

Conor O'Brien
fuente
1

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

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

primer golf, creo que hice bien en

downrep_nation
fuente
1

C, 74 73 71 bytes

¡Afeitado un byte tres gracias a @xsot!

a[99],c,m;main(d){for(;~c;m|=c^d&&a[d=c]++)c=getchar();putchar(48+!m);}
milIbyte
fuente
a[99] I love Perl's autovivification! Oh, wait...
cat
I think this works: a[99],c,m;main(d){for(;~c;m|=a[d=c]+=c!=d)c=getchar();putchar(48+1/m);}
xsot
@xsot - Thank you for shaving one byte by replacing !--m with 1/m. About a[d=c]+=c!=d, I tried it with gcc and it didn't work on my computer because of order of evaluation. We must find a compiler that will play along.
mIllIbyte
Oh, I just tested it on ideone and it worked fine. How about this: a[99],c,m;main(d){for(;~c;m|=c^d&&a[d=c]++)c=getchar();putchar(48+!m);}
xsot
1

Haskell, 37 bytes

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

Uses the same approach as Luis Mendo's MATL answer: creates a vector for each entry which indices equal it, and checks that the result is sorted in decreasing order.

(<$>l).(==)<$>l is shorter version of [map(==a)l|a<-l]. The function (<$>l).(==) that takes a to map(==a)l is mapped onto l.

scanl1 min takes the cumulative smallest elements of l, which equals the original only if l is reverse-sorted. (==)=<< checks if the list is indeed invariant under this operation.

A different recursive strategy gave 40 bytes:

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

This checks each suffix to see if its first element doesn't appear in the remainder, excusing cases where the first two elements are equal as part of a contiguous block.

xnor
fuente
1

Racket, 53 bytes

The dumb, simple 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)))

Racket, 86 bytes

Here's the version implementing @xnor's comment about more efficient ways to do this.

(λ(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, this may actually just shift the weight of computation from the sort function to regexp-replace, but it was an interesting solution. Basically, it removes runs of duplicate characters first (see here), then tests if the remaining length-1 runs are in sorted fashion.

cat
fuente
1

Perl 5, 20 bytes

19, plus 1 for -pe instead of -e.

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

Wolfram Language (Mathematica), 18 bytes

Gather@#==Split@#&

Try it online!

Gather gathers a list into sublists of identical elements, and Split splits a list into sublists of consecutive identical elements. They give the same result if and only if each value appears in only one contiguous block.

Misha Lavrov
fuente
0

Japt, 9 bytes

ò¦ mÌ
eUâ

Try it

Explanation

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