Generador de ID sin pares contiguos coincidentes


16

Dadas 2 entradas (m = identificación inicial mínima , n = número de identificadores ), genera una lista secuencial de identificadores, comenzando en> = m, compuesta por los dígitos 0-9 donde no hay 2 números contiguos iguales, por ejemplo, 1232 es ok, 1233 no lo es (contiene 2 '3 al lado del otro).

Ejemplo

para m = 985, n = 6, a continuación se muestran los identificadores que se generarían / ​​omitirían

...
985 - ok, 1st
986 - ok, 2nd
987 - ok, 3rd
# skip 0988 (contains '88')
989 - ok, 4th
# Skip 099x (contains '99')
# Skip 100x (contains '00')
1010 - ok, 5th
# Skip 1011 (contains '11')
1012 - ok, 6th
...

Salida

Cada ID debe imprimirse en una nueva línea, como en la secuencia anterior:

985
986
987
989
1010
1012

Reglas

Reglas estándar de código de golf, el conteo de bytes más bajo gana


14
Bienvenido a PPCG! Cada ID debe imprimirse en una nueva línea. No recomiendo restringir explícitamente la salida a un formato particular.
Erik the Outgolfer

3
¿Está bien devolver una lista de ID (es decir, una matriz 1-D de enteros), en lugar de imprimir en stdout?
JungHwan Min

44
@ user202729 Las respuestas no se invalidarán en este caso.
Erik the Outgolfer

2
@ user202729 Eso no invalida las respuestas ... En todo caso, las respuestas se solucionarán o simplemente seguirán las viejas reglas.
Totalmente humano

3
Para aquellos escritos en idiomas de golf, cambiar la regla para permitir más formatos de salida no los afectaría. Por lo demás, puede dejar un comentario diciendo que el formato de salida ya no está restringido.
Brad Gilbert b2gills

Respuestas:


3

Jalea , 6 bytes

DIẠµ#Y

Pruébalo en línea!

¿Cómo funciona?

DIẠµ # Y - Programa completo. Argumento: dos enteros, X e Y.

   µ #: devuelve los primeros enteros Y superiores o iguales a X que satisfacen:
 I - Los incrementos ...
D - ... De sus dígitos de base 10 ...
  Ạ - ... Son todos distintos de 0. 
     Y - Unir el resultado por nuevas líneas.

8

Brachylog , 11 10 bytes

{≤ṫẹ~ḅẉ}ᶠ⁾

La entrada es una lista de dos números. Pruébalo en línea!

Explicación

El incorporado toma una lista o cadena, como "1000220", y la divide en bloques de elementos adyacentes iguales, como ["1","000","22","0"]. En este programa, le aplico el ~operador, por lo que funciona a la inversa: toma una lista de cadenas, comprueba que cada cadena consta de repeticiones de un solo carácter y las cadenas vecinas tienen caracteres diferentes, y concatena la lista. El predicado enumera los números comenzando desde la primera entrada en orden creciente, y verifico una condición en ellos, imprimiendo los que lo satisfacen y deteniéndome cuando encuentro suficiente.

{≤ṫẹ~ḅẉ}ᶠ⁾  Input is a pair, say [M=988,N=3].
{      }ᶠ⁾  Apply this predicate to M and compute the first N results.
 ≤          Take a number that is greater than or equal to M (first up is 988).
  ṫ         Convert it to string: "988"
   ẹ        Split it into substrings of length 1: ["9","8","8"]
     ~ḅ     Apply ḅ in reverse: fails, try next number.
       ẉ    If ḅ succeeds, print the resulting string and a newline.
            This counts as a result of the predicate.

6

05AB1E , 9 bytes

µÐÔQi=¼}>

Pruébalo en línea!

Exlpacion

µ           # loop until counter equals n
 Ð          # triplicate current value (initially m)
  Ô         # connected uniqueified on the copy at the top of the stack
   Q        # compare to unmodified for equality
    i  }    # if true
     =      # print current value while leaving it on the stack
      ¼     # increment the counter
        >   # increment current value

4

Java 8, 83 bytes

(m,n)->{for(;n>0;m++)if(!(m+"").matches(".*(.)\\1.*")){System.out.println(m);n--;}}

Explicación:

Pruébalo en línea.

(m,n)->{                      // Method with two integer parameters and no return-type
  for(;n>0;                   //  Loop as long as `n` is larger than 0
      m++)                    //    After every iteration: increase `m` by 1
    if(!(m+"").matches(".*(.)\\1.*")){
                              //   If there are no repeated adjacent digits:
      System.out.println(m);  //    Print `m`
      n--;}}                  //    And decrease `n` by 1

Muy agradable. Por curiosidad, ¿dónde sería el foro apropiado para esta pregunta donde el desafío no era "bytes" sino "eficiencia"?
beirtipol

1
@beirtipol ¿Por más eficiente quiere decir el tiempo de ejecución más rápido? En ese caso, probablemente también aquí en PPCG, con las etiquetas code-challenge y el código más rápido . Aunque publicar exactamente el mismo desafío ahora y cambiar el código de golf al código más rápido probablemente todavía se cerrará como un engaño ...
Kevin Cruijssen

3

PowerShell , 59 bytes

param($m,$n)for(;$n){if("$m"-notmatch"(.)\1"){$m;$n--}$m++}

Pruébalo en línea!

Básicamente similar a las otras respuestas. Bucles siempre que nos queden números para imprimir ( for(;$n)), comprueba si tenemos una coincidencia de expresiones regulares contra un doble dígito y, de lo contrario, lo pone en la tubería y disminuye $n. Luego incrementamos $my repetimos nuevamente. Los elementos se recogen de la tubería y lo implícito Write-Outputnos da una salida separada de la nueva línea de forma gratuita.


3

R , 111 92 71 bytes

function(m,n)while(F<n){if(!grepl("(.)\\1",m)){cat(m,'
');F=F+1}
m=m+1}

Pruébalo en línea!

Utiliza greplpara buscar dígitos repetidos.


No te unes al resultado con nuevas líneas, y el OP no respondió si esto todavía está permitido (aunque espero que esté bien)
Sr. Xcoder

@ Mr.Xcoder ah, claro, me di cuenta de eso y luego copié y pegué la versión incorrecta :(
Giuseppe



2

Perl 6 , 56 bytes

{.put for grep({none .comb Zeq.comb.skip},$^a..*)[^$^b]}

Intentalo

Expandido:

{  # bare block lambda with placeholder params $a $b

  .put for

  grep(

    {
      none          # create a none junction (True if all are False)

        .comb       # the input split into digits
        Zeq         # Zip using &infix:«eq» operator
        .comb.skip  # the input split into digits starting at second one
    },

    $^a .. *        # a Range starting at the first argument

  )[ ^ $^b ]        # take the first $b values
}

2

Retina , 34 bytes

.0A`
"$+"{\/(.)\1/{`.+
*
)C`
.+
*

Pruébalo en línea! Toma ny mcomo entrada en líneas separadas. Explicación:

.0A`

Apague la salida automática y elimine ndel búfer de trabajo.

"$+"{

Repite nveces.

\

Imprima el valor de mal final del siguiente grupo en bucle.

/(.)\1/{`

Bucle mientras hay dígitos contiguos.

.+
*

Convierte a unario.

)C`

Cuente el número de cadenas vacías, que es uno más que el número de caracteres, sumando 1 y convirtiendo de nuevo a decimal. Esto termina el ciclo interno.

.+
*

Después de imprimir m, agregue 1 nuevamente de la misma manera. (La última línea no necesita un C`porque es el tipo de etapa predeterminado para la última línea). El bucle externo está implícitamente terminado.

Tenga en cuenta que convertir a unario y volver a decimal es un poco lento; para 39 bytes, una versión que no realiza ninguna conversión:

.0A`
"$+"{\/(.)\1/+`.+
$.(*__
.+
$.(*__

Pruébalo en línea! Explicación: $.(calcula la longitud del resto de la sustitución, convenientemente sin expandirla realmente; como la longitud de *_es implícitamente el valor coincidente y la longitud de _es, por supuesto, 1, esto solo incrementa el valor.


2

Perl 5.10.0 + -n, 40 39 bytes

for(;$i;$_++){!/(.)\1/&&$i--&&say}$i=$_

Pruébalo en línea!

-1 byte gracias a Xcali

Entrada en dos líneas, primero n, luego m. Asegúrese de que NO haya nueva línea después de m:

(echo '6'; echo -n '985') | perl -nE 'for(;$i;$_++){!/(.)\1/&&$i--&&say}$i=$_'

1
Puede eliminar la 'm' para guardar un byte.
Xcali

Gracias @Xcali, no saben lo que estaba pensando ...
Wastl

2

Perl 5 , -ln33 bytes

Ingrese 2 líneas en STDIN, primero inicie la identificación y luego cuente

#!/usr/bin/perl -ln
$n-=!/(.)\1/&&say,$_++while$n.=<>

Pruébalo en línea!


No sabía que $n.=<>funcionaba así, especialmente con el -=...
Dom Hastings

@DomHastings Desafortunadamente, tendré que revertirlo, ya que $npuede ser 0así que hacer ambas cosas juntas está mal
Ton Hospel


1

Haskell , 70 bytes

-19 bytes gracias a nimi.

s#n=unlines$map show$take n$filter(and.(zipWith(/=)=<<tail).show)[s..]

Pruébalo en línea!

17 bytes dedicados a la separación por nuevas líneas.



No te unes al resultado con nuevas líneas, y el OP no respondió si esto todavía está permitido (aunque espero que esté bien)
Sr. Xcoder

@ Mr.Xcoder Agh, arreglando ...
totalmente humano

1
Puedes usar mapMy print. Pruébalo en línea!
nimi

1

Stax , 9 8 bytes CP437

ç@F6╕↔┤ú

Pruébalo en línea!

Sucede para coincidir con el algoritmo de @ Mr.Xcoder en su respuesta de Jelly.

-1 byte por comentario de @recursive.

Explicación

Utiliza el formato desempaquetado para explicar.

{$:-|A}gn
{     }gn    Generator, generate given number of values, using block as a filter
                 And implicit output, one element on a line.
             In Stax, only 0 and [] is falsy.

 $           Convert the number to string
  :-         Difference between contiguous digit
    |A       All of them are truthy (may use `:*` as well)

staxlang.xyz/… da 8 bytes. La evaluación implícita funciona en varios valores siempre que estén en la primera línea de entrada estándar.
recursivo

@recursive Gracias, eso es algo que no noté aunque está documentado.
Weijun Zhou

1

Haskell , 94 93 91 bytes

-1 byte gracias a Laikoni
-2 bytes gracias a Zgarb

import Data.List
a!0=[]
a!b|all(null.tail)$group$show a=show a++'\n':(a+1)!(b-1)|c<-a+1=c!b

Pruébalo en línea!

Primero Haskell golf.


1
Bienvenido a Haskell golf! group(show a)puede ser group$show a.
Laikoni

2
(<2).lengthpuede sernull.tail
Zgarb





0

AWK , 90 bytes

{for(j=$1;k<$2;j++){for(a=b=d;++b<=(n=split(j,A,""))&&a!=c=A[b];a=c);if(n<b&&++k)print j}}

Pruébalo en línea!

Esto es mucho más feo de lo que pensé que sería. Descubrí que AWKsolo tiene sustitución de retroceso en su gensubfunción, lo que haría que su uso no fuera muy eficiente.

Por lo tanto, este es un enfoque muy sencillo de incrementar un contador de ID, dividir el contador en cada carácter, recorrer los caracteres para ver si algún carácter es el mismo que el anterior. Si no se encuentran caracteres repetidos, imprima el contador de ID e incremente el número de ID impresos.

Intentaré abstenerme de hacer una declaración en la línea de " AWKdebería tener la capacidad de hacer expresiones regulares más robustas", pero será difícil.




0

Pip , 22 bytes

--aLb{W`(.)\1`N++a0Pa}

Pruébalo en línea!

Explicación

--aLb{W`(.)\1`N++a0Pa}
                        a,b are command-line arguments
--a                     Decrement a
   Lb{               }  Loop b times:
       `(.)\1`           Regex matching a character followed by itself
      W       N++a       While that regex matches in incremented a:
                  0       No-op
                   Pa    When the while loop exits, a is a valid ID; print it
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.