Números que son fáciles de recordar pero que en ^teoría no son fáciles de hacer.

Su desafío es crear un programa / función en cualquier idioma que genere números uniformemente aleatorios que se ajusten a estos criterios:

1. La longitud es de 5 dígitos.

2. Hay dos pares de dígitos repetidos separados

3. Un conjunto de dígitos repetidos está al principio o al final y los dígitos están uno al lado del otro

4. El número impar está rodeado por el otro par de dígitos.

5. Los dos pares de dígitos y el otro número deben ser únicos.

6. Su programa puede admitir números con ceros a la izquierda o no, a su discreción. Si los ceros iniciales son compatibles, deben incluirse en la salida: 06088, no 6088. Si los ceros iniciales no son compatibles, entonces no deberían generarse números como 06088.

Casos de prueba

Salidas aceptadas:

55373
55494
67611
61633
09033
99757
95944
22808
65622
22161

Salidas no aceptadas:

55555
77787
85855
12345
99233
12131
a B C D e
5033

Se pueden encontrar casos de prueba más aceptables en este enlace de pastebin .

Estos se hicieron con este programa de Python:

importar al azar
para i en rango (100):

    if random.randint (0,100)> = 50: #Poner par tocando al principio si es verdadero
        temp = [] # matriz de trabajo
        temp.append (random.randint (0,9)) #append dígito aleatorio
        temp.append (temp [0]) #aplica el mismo dígito nuevamente

        x = random.randint (0,9)
        mientras x == temp [0]:
            x = random.randint (0,9)
        temp.append (x) #append otro dígito único

        y = random.randint (0,9)
        mientras y == temp [0] o y == temp [2]:
            y = random.randint (0,9)
        temp.append (y) #append otro dígito único y el dígito único anterior
        temp.append (x)

    más: #Ponga el par tocando al final
        temp = [] # matriz de trabajo  
        temp.append (random.randint (0,9)) #append dígito aleatorio

        # Si bien no es único, intente nuevamente
        x = random.randint (0,9)
        mientras x == temp [0]:
            x = random.randint (0,9)
        temp.append (x) #append otro dígito único


        temp.append (temp [0]) #aplica nuevamente el mismo 0º dígito


        y = random.randint (0,9)
        mientras y == temp [0] o y == temp [1]:
            y = random.randint (0,9)
        temp.append (y) #append dos dígitos únicos dos veces
        temp.append (y)

    tempstr = ""
    para yo en temp:
        tempstr + = str (i)
    imprimir tempstr

Este es el código de golf , ¡así que la respuesta más corta en bytes gana!

05AB1E , 11 bytes

žh.r3£ûÁÂ)Ω

Pruébalo en línea!

Explicación

žh            # push "0123456789"
  .r          # random shuffle
    3£        # take the first 3
              # EX: 152
      û       # palendromize
              # EX: 15251
       Á      # rotate right
              # EX: 11525
        Â)    # pair with its reverse
              # EX: [11525, 52511]
          Ω   # pick one at random

CJam (16 bytes)

YmrG*98+ZbA,mrf=

Demostración en línea

Nota: He asumido que por OP "único" realmente significa "distinto".

También para 16 bytes:

98ZbA,mrf=W2mr#%
98ZbA,mrf=_W%]mR

Disección

Ymr    e# Select a random number from [0 1]
G*98+  e# Multiply by 16 and add 98 to get 98 or 114
Zb     e# Base conversion in base 3 to get [1 0 1 2 2] or [1 1 0 2 0]
A,mr   e# Shuffle the numbers from 0 to 9
f=     e# Map "select the item at this index"

Las otras variantes generan usando [1 0 1 2 2]y luego seleccionan el resultado o su reverso.

Perl 5 , 81 63 56 bytes

Corte 7 bytes con inspiración de @DomHastings

Construyendo el número a partir del patrón apropiado.

@q{0..9}++;say+(keys%q)[.5>rand?(2,2,0,1,0):(0,1,0,2,2)]

Pruébalo en línea!

Perl 5 , 89 bytes

Selecciona números aleatorios de 5 dígitos hasta que encuentre uno que cumpla con los criterios.

$_=sprintf'%05d',0|rand 1E5until(/(.)\1(.)(.)\2/||/(.)(.)\1(.)\3/)&&$1-$2&$2-$3&$1-$3;say

Pruébalo en línea!

Python 2 , 80 bytes

from random import*
a,b,c=sample(range(10),3)
print[a,a,b,c,b][::choice((-1,1))]

Pruébalo en línea!

Emite una lista de dígitos.

Python 2 , 83 bytes

from random import*
a,b,c=sample('0123456789',3)
print(a*2+b+c+b)[::choice((-1,1))]

Pruébalo en línea!

La salida es un número.

APL (Dyalog Unicode) , 22 21 20 18 17 bytes

(3∨?2)⌽1↓,∘⌽⍨3?10

Pruébalo en línea!

Si es aceptable generar los números siempre en el mismo formato, esto se puede acortar a 12 bytes, ya sea 1⌽1↓,∘⌽⍨3?10o 3⌽1↓,∘⌽⍨3?10.

Guardado un byte eliminando lo innecesario ∘.

Guardado un byte gracias a H.PWiz, y luego 2 bytes más debido a su propina.

Guardado un byte gracias a ngn.

La función asume ⎕IO←0( I ndex O rigin).

¿Cómo?

(3∨?2)⌽1↓,∘⌽⍨3?10 ⍝ Anonymous function.
              3?10  ⍝ Deal 3 (distinct) random numbers from 0 to 9. (Assume 1 2 3)
             ⍨     ⍝ Use that as both arguments for:
          ,∘⌽      ⍝ Rotate (⌽), then concatenate (,).
                   ⍝ Yields 3 2 1 1 2 3.
        1↓         ⍝ Drop the first element. Our vector is now 2 1 1 2 3
      ⌽            ⍝ Rotate the vector to the left using as argument:
(  ?2)             ⍝ Roll 0 or 1 and...
 3∨                ⍝ Do the GCD between 3 and the result. (3∨0=3; 3∨1=1.)
                   ⍝ This yields either 1 1 2 3 2 or 2 3 2 1 1.

Java 8, 145 136 125 119 bytes

v->{String r;for(;!(r=(int)(Math.random()*1e5)+"").matches("((.).?\\2){2}")|r.chars().distinct().count()<3;);return r;}

-9 bytes gracias a @ OlivierGrégoire.
-11 bytes gracias a @RickHitchcock .
-6 bytes gracias a @Nevay .

Explicación:

Pruébalo en línea.

v->{            // Method with empty unused parameter and String return-type
  String r;     //  Result-String
  for(;!(r=(int)(Math.random()*1e5)+"")
                //  Generate a random number in the range [0; 100000) and set it to `r`
        .matches("(.).*\\1(.).*\\2")
                //   And continue doing this as long as it doesn't match the regex above,
       |r.chars().distinct().count()<3;);
                //   or doesn't have three distinct digits
  return r;}    //  Return the result

Jalea , 23 bytes

⁵Ḷṗ3⁼Q$ÐfXµḢ;`;ŒBW;U$µX

Pruébalo en línea!

Jalea , 12 11 bytes

ØDẊ⁽0yṃ,U$X

Pruébalo en línea!

Explicación

ØDẊ⁽0yṃ,U$X    Niladic link, generate a random string.
ØD             List of digits, ['0','1','2',...,'9'].
  Ẋ            Random shuffle.
   ⁽0y         Number 13122.
      ṃ        Base decompression. (*)
       ,U$     Pair with its upend (reverse).
          X    Choose one (it or its reversed) randomly.

^(*) El argumento correcto de ṃes que la lista ['0','1','2',...,'9'], aleatoriamente barajada, tiene 10 elementos. Por lo tanto, el número 13122se convertirá en la base biyectiva 10 ( [1,3,1,2,2]) y se indexará en la lista (por lo tanto, si la lista es l, el valor de retorno del átomo es [l[1],l[3],l[1],l[2],l[2]], donde Jelly usa la indexación basada en 1)

JavaScript (ES6), 79 bytes

f=([,,d,a,b,c]=[...Math.random()+f])=>a-b&&a-c&&b-c?d&1?a+a+b+c+b:b+c+b+a+a:f()

Pruébalo en línea!

¿Cómo?

Math.random()da un flotante aleatorio en [0..1) . Usamos +fpara forzar la coerción a una cadena. Ignoramos el cero inicial y el punto decimal haciendo [,,( desestructurando la asignación de los dos primeros caracteres a nada) y recolectamos los primeros 4 dígitos decimales en d , a , b y c .

Si un , b y c son números enteros distintos 3, construimos el resultado final, ya sea en AABCB o BCBAA formato (utilizando la paridad de d para decidir). De lo contrario, lo intentamos nuevamente hasta que lo estén.

En el caso altamente improbable de Math.random()devolver un valor sin suficientes decimales, al menos c se establecerá en un carácter que no sea un dígito, lo que obligará a que la prueba falle y se produzca la llamada recursiva. Si un , b y c son números enteros válidos entonces d se garantiza que sea un número entero válido también, así que ésta no tiene que ser probado.

Perl 6 , 42 bytes

[~] (^10).pick(3)[0,|(<0 2 1>,<1 0 2>).pick,2]

Pruébalo en línea!

Sucio , 33 bytes

Utiliza la --numeric-outputbandera para que sea legible, de lo contrario, generaría una cadena de caracteres de control con puntos de código correspondientes a los dígitos.

10⭧[1w#%D⅋№3⤱≠1ẅ&]1wẂ⭿⭣1u∅#1∧◌ŪW‼

Pruébalo en línea!

Explicado:

10⭧              put 10 on the right stack
[1w#%D⅋№3⤱≠1ẅ&] loop until there are 3 distinct positive numbers below 10 in the top stack
1wẂ              clean-up the right and top stacks
⭿               copy the top and bottom of the top stack to each-other
⭣                swap the first two elements of the top stack
1u               rotate the top stack by 1
∅#1∧◌ŪW          reverse the top stack half of the time
‼                print the top stack

Carbón , 34 bytes

≔‽χθ≔‽Φχ⁻ιθη↑Ｉ⟦θθη‽Φχ×⁻ιθ⁻ιηη⟧¿‽²‖

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

  χ                                 Predefined variable 10
 ‽                                  Random element from implicit range
≔  θ                                Assign to variable `q`
       χ                            Predefined variable 10
      Φ                             Filter on implicit range
         ι                          Current value
          θ                         Variable `q`
        ⁻                           Subtract
     ‽                              Random element
    ≔      η                        Assign to variable `h`
                    χ               Predefined variable 10
                   Φ                Filter on implicit range
                       ι  ι         Current value
                        θ           Variable `q`
                           η        Variable `h`
                      ⁻  ⁻          Subtract
                     ×              Multiply
                  ‽                 Random element
               θθ                   Variable `q`
                 η          η       Variable `h`
              ⟦              ⟧      Wrap 5 values into array
             Ｉ                      Cast array elements to string
            ↑                       Make array print horizontally
                                ²   Literal 2
                               ‽    Random element from implicit range
                              ¿     If
                                 ‖  Reflect

Retina , 40 bytes

10*
Y`w`d
V?`
Lv$7`.(.)
$1$<'$'
O?`...?

Pruébalo en línea!

Puede imprimir cadenas con ceros a la izquierda.

Explicación

10*

Inicialice la cadena a 10 guiones bajos.

Y`w`d

Transliterar cíclicamente caracteres de palabras a dígitos. Esto es un poco raro Los wy dson cortos para las siguientes cadenas, respectivamente:

w: _0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
d: 0123456789

La transliteración cíclica significa que primero, ambas cadenas se repiten a la longitud de su LCM:

_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_012345...
0123456789012345678901234567890123456789012345678901234567890123456789...

Dado que las longitudes de cadena 53 y 10 son coprimas, cada copia de _se empareja con un dígito diferente. Y ahora transliteración cíclica sustituirá a la i ª copia de _la i º emparejamiento en esa lista ampliada. Entonces terminamos con la siguiente cadena:

0369258147

Todo eso para guardar un solo byte sobre la cadena literal 0369258147, así que, supongo. :RE

De todos modos, tenemos una cadena de los 10 dígitos ahora.

V?`

Esto baraja los dígitos. Por lo tanto, los primeros tres dígitos serán una selección aleatoria uniforme de tres dígitos distintos.

Lv$7`.(.)
$1$<'$'

Emparejamos la cuerda ...ABCy la convertimos BABCC. Sin embargo, la forma en que hacemos esto es un poco loco y, de nuevo, solo guarda un byte en comparación con un enfoque más directo. Primero hacemos coincidir todos losv pares de caracteres superpuestos ( ), capturando el segundo ( .(.)). Luego conservamos solo la octava coincidencia ( 7basada en cero) que está ABen ...ABC. Luego lo reemplazamos ( $) con: B( $1), ABC( $<'que es el sufijo del separador de coincidencias a la izquierda de la coincidencia), C( $'que es el sufijo de la coincidencia misma).

O?`...?

Finalmente, combinamos 3 o 2 caracteres y barajamos las coincidencias, dándonos al azar BABCCo CCBABal azar.

R , 78 bytes

z=sample(0:9,3)[c(2,1:3,3)];cat(paste(`if`(runif(1)>.5,z,rev(z)),collapse=''))

Pruébalo en línea!

samplerecoge 3 valores aleatorios de 0:9, que se colocan en un vector de este modo: a b a c c. Ahora tenemos una posibilidad de 50/50 de revertir este vector, y luego concatenar e imprimir.

PHP, 73 72 66 bytes

<?=strtr(rand()%2?AABCB:BCBAA,ABC,join(array_rand(range(0,9),3)));

Editar: 66 bytes gracias a la sugerencia de @David.

Pruébalo en línea!

Rojo , 147, 146125 bytes

func[][b: copy[]d:[1 1 2 3 2]if 1 = random 2[d: reverse d]while[4 > length? b][alter b(random 10)- 1]foreach a d[prin b/(a)]]

Pruébalo en línea!

Sin golf:

f: func[] [                       function with no arguments
    b: copy []                    an empty list
    d: [1 1 2 3 2]                preset digits at positons
    if 1 = random 2 [             generate 1 or 2 
        d: reverse d]             based on this choose to reverse the positions list
    while [4 > length? b] [       while we haven't chosen 3 different digits
        alter b (random 10) - 1   pick a random digit, if it's not in the list already
                                  append it to the list, otherwise remove it
    ]
    foreach a d [                 for each position
       prin b/(a)]                print the corresponding digit 
]

Wolfram Language (Mathematica) , 59 bytes

{{#,##,#2},{#2,##,#3}}~r~1&@@(r=RandomSample)[0~Range~9,3]&

Pruébalo en línea!

Ruby , 60 59 bytes

->{a,b,c=[*0..9].sample 3;[[a,a,b,c,b],[b,c,b,a,a]].sample}

Pruébalo en línea!

Devuelve una lista de dígitos.

Python 3 + numpy, 69 bytes

from pylab import*
r=choice
i=r(2)
print(r(10,3,0)[[1-i,0,1,2,-1-i]])

Explicación

from pylab import*     
r=choice               # `choice` takes a range, number of samples, and wether repetition is allowed
i=r(2)                 # Single value in [0,1] to specify if repeated digits come on right or left
print(r(10,3,0)[[1-i,0,1,2,-1-i]])    # Construct output using index list and 3 random integers

C (gcc) , 126 119 bytes

-6 bytes de @ceilingcat

#define R time(0)%10
b,n,m,k;f(){b=R^8;for(n=R;m==n|k==m|k==n;m=R,k=R);printf("%d%d%d%d%d",b?n:m,b?n:k,m,b?k:n,b?m:n);}

Pruébalo en línea!

J , 35 bytes

[:u:48+[:|.^:(?&2:)2 2 1 0 1{3?10"_

Pruébalo en línea!

Estoy seguro de que se puede jugar mucho más.

Explicación:

  3?10             - generates 3 different digits
7 0 3

  2 2 1 0 1{       - constructs a list using digits positions 0, 1 and 2

  2 2 1 0 1{3?10   
3 3 0 7 0

  |.^:(?&2:)       - generates 0 or 1 and if 1, reverses the list 

  |.^:(?&2:)2 2 1 0 1{3?10
0 7 0 3 3

   u:48+              - converts to char by adding 48 to each digit
   u:48+|.^:(?&2:)2 2 1 0 1{3?10
07033