Números fáceis de lembrar, mas ^teoricamente não são fáceis

Seu desafio é criar um programa / função em qualquer idioma que gere números aleatoriamente uniformes que atendam a esses critérios:

1. O comprimento é de 5 dígitos

2. Existem dois pares de dígitos repetidos separados

3. Um conjunto de dígitos repetidos está no início ou no final e os dígitos estão próximos um do outro

4. O número ímpar é cercado pelo outro par de dígitos

5. Os pares de dois dígitos e o outro número devem ser únicos

6. Seu programa pode suportar números com zeros à esquerda ou não, a seu critério. Se os zeros iniciais forem suportados, eles deverão ser incluídos na saída: 06088, não 6088. Se os zeros iniciais não forem suportados, números como 06088 não deverão ser gerados.

Casos de teste

Saídas aceitas:

55373
55494
67611
61633
09033
99757
95944
22808
65622
22161

Saídas não aceitas:

55555
77787
85855
12345
99233
12131
abcde
5033

Casos de teste mais aceitáveis ​​podem ser encontrados neste link pastebin .

Estes foram feitos com este programa python:

importação aleatória
para i na faixa (100):

    if random.randint (0,100)> = 50: #Put pair tocando no início se true
        temp = [] # matriz de trabalho
        temp.append (random.randint (0,9)) #append digit random
        temp.append (temp [0]) # acrescente o mesmo dígito novamente

        x = random.randint (0,9)
        enquanto x == temp [0]:
            x = random.randint (0,9)
        temp.append (x) #append outro dígito exclusivo

        y = random.randint (0,9)
        enquanto y == temp [0] ou y == temp [2]:
            y = random.randint (0,9)
        temp.append (y) # anexa outro dígito exclusivo e o dígito exclusivo anterior
        temp.append (x)

    else: #Coloque o par no final
        temp = [] # matriz de trabalho  
        temp.append (random.randint (0,9)) #append digit random

        # Embora não seja exclusivo, tente novamente
        x = random.randint (0,9)
        enquanto x == temp [0]:
            x = random.randint (0,9)
        temp.append (x) #append outro dígito exclusivo


        temp.append (temp [0]) # adicione novamente o mesmo 0º dígito


        y = random.randint (0,9)
        enquanto y == temp [0] ou y == temp [1]:
            y = random.randint (0,9)
        temp.append (y) # anexa outro dígito exclusivo duas vezes
        temp.append (y)

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

Isso é código-golfe , então a resposta mais curta em bytes vence!

05AB1E , 11 bytes

žh.r3£ûÁÂ)Ω

Experimente online!

Explicação

ž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=

Demonstração online

Nota: Eu assumi que por OP "único" realmente significa "distinto".

Também para 16 bytes:

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

Dissecação

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"

As outras variantes geram usando [1 0 1 2 2]e, em seguida, selecione o resultado ou seu inverso.

Perl 5 , 81 63 56 bytes

Corte 7 bytes com inspiração em @DomHastings

Construindo o número a partir do padrão apropriado.

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

Experimente online!

Perl 5 , 89 bytes

Seleciona números aleatórios de 5 dígitos até encontrar um que atenda aos critérios.

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

Experimente online!

Python 2 , 80 bytes

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

Experimente online!

Produz uma 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))]

Experimente online!

Saída é um número.

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

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

Experimente online!

Se for aceitável gerar os números sempre no mesmo formato, isso pode ser reduzido para 12 bytes, 1⌽1↓,∘⌽⍨3?10ou 3⌽1↓,∘⌽⍨3?10.

Salve um byte removendo o desnecessário ∘.

Salvou um byte graças a H.PWiz e mais 2 bytes devido à dica.

Guardou um byte graças a ngn.

A função assume ⎕IO←0( I NDEX O Rigin).

Quão?

(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 graças a @ OlivierGrégoire.
-11 bytes graças a @RickHitchcock .
-6 bytes graças a @Nevay .

Explicação:

Experimente online.

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

Gelatina , 23 bytes

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

Experimente online!

Geléia , 12 11 bytes

ØDẊ⁽0yṃ,U$X

Experimente online!

Explicação

Ø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.

^(*) O argumento correto de ṃé que a lista ['0','1','2',...,'9'], aleatoriamente aleatória, possui 10 elementos. Portanto, o número 13122será convertido na base bijetiva 10 ( [1,3,1,2,2]) e indexado na lista (portanto, se a lista for l, o valor de retorno do átomo é [l[1],l[3],l[1],l[2],l[2]]onde Jelly usa a indexação baseada em 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()

Experimente online!

Quão?

Math.random()dá uma flutuação aleatória em [0..1) . Usamos +fpara forçar a coerção a uma corda. Nós ignoramos o zero eo ponto decimal fazendo [,,( desestruturação atribuição dos dois primeiros caracteres para nada) e recolher os 4 primeiros dígitos decimais em d , a , b , e c .

Se um , b e c são números inteiros 3 distintas, nós construímos o produto final em qualquer AABCB ou BCBAA formato (utilizando a paridade de d a decidir). Caso contrário, tentamos novamente até que estejam.

No evento altamente improvável de Math.random()retornar um valor sem casas decimais suficientes, pelo menos c será definido como um caractere não dígito, forçando o teste a falhar e a chamada recursiva a ocorrer. Se a , b e c são inteiros válidos, em seguida, d é garantido para ser um inteiro válido, bem como, assim que este não precisa ser testado.

Perl 6 , 42 bytes

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

Experimente online!

Sujo , 33 bytes

Usa o --numeric-outputsinalizador para que seja legível; caso contrário, ele produziria uma sequência de caracteres de controle com pontos de código correspondentes aos dígitos.

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

Experimente online!

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

Carvão , 34 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

  χ                                 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?`...?

Experimente online!

Pode imprimir strings com zeros à esquerda.

Explicação

10*

Inicialize a sequência para 10 sublinhados.

Y`w`d

Transliterar ciclicamente os caracteres das palavras em dígitos. Isso é um pouco estranho. The we dsão abreviações para as seguintes seqüências, respectivamente:

w: _0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
d: 0123456789

Transliteração cíclica significa que primeiro, ambas as cadeias são repetidas para o comprimento do seu LCM:

_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_012345...
0123456789012345678901234567890123456789012345678901234567890123456789...

Como os comprimentos de sequência 53 e 10 são coprime, cada cópia de _é emparelhada com um dígito diferente. E agora transliteração cíclica irá substituir o i th cópia do _com o i th emparelhamento nessa lista expandida. Então, acabamos com a seguinte string:

0369258147

Tudo isso para salvar um único byte sobre a string literal 0369258147, então sim, eu acho? : D

De qualquer forma, temos uma sequência de todos os 10 dígitos agora.

V?`

Isso embaralha os dígitos. Portanto, os três primeiros dígitos serão uma seleção uniformemente aleatória de três dígitos distintos.

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

Nós combinamos a corda ...ABCe a transformamos BABCC. A maneira como fazemos isso é meio louca e, novamente, economiza apenas um byte em comparação com uma abordagem mais direta. Primeiro, combinamos todos os pares de caracteres sobrepostos ( v), capturando o segundo ( .(.)). Então nós reter apenas o 8º jogo ( 7, baseado em zero), que é ABno ...ABC. Em seguida, substituímos ( $) por: B( $1), ABC( $<'que é o sufixo do separador de correspondências à esquerda da correspondência), C( $'que é o sufixo da própria correspondência).

O?`...?

Finalmente, combinamos 3 ou 2 caracteres e embaralhamos as partidas, dando-nos BABCCou CCBABaleatoriamente.

R , 78 bytes

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

Experimente online!

samplepega 3 de valores aleatórios 0:9, que são colocados em um vector da seguinte forma: a b a c c. Agora temos 50/50 de chance de reverter esse vetor e concatenar e imprimir.

PHP, 73 72 66 bytes

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

Edit: 66 bytes graças à sugestão de @David.

Experimente online!

Vermelho , 147, 146 125 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)]]

Experimente online!

Ungolfed:

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]&

Experimente online!

Ruby , 60 59 bytes

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

Experimente online!

Retorna uma 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]])

Explicação

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

Experimente online!

J , 35 bytes

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

Experimente online!

Tenho certeza de que pode ser jogado muito mais longe.

Explicação:

  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