FACILE memorizzare numeri


41

Numeri facili da ricordare ma teoricamente non facilmente realizzabili

La tua sfida è creare un programma / funzione in qualsiasi lingua che generi numeri casualmente uniformi che soddisfino questi criteri:

  1. La lunghezza è di 5 cifre

  2. Esistono due coppie di cifre ripetute separate

  3. Una serie di cifre ripetute è all'inizio o alla fine e le cifre sono una accanto all'altra

  4. Il numero dispari è circondato dall'altra coppia di cifre

  5. Le coppie di due cifre e l'altro numero dovrebbero essere univoci

  6. Il tuo programma può supportare numeri con zero iniziali o meno, a tua discrezione. Se gli zero iniziali sono supportati, devono essere inclusi nell'output: 06088, non 6088. Se gli zero iniziali non sono supportati, i numeri come 06088 non devono essere generati affatto.

Casi test

Uscite accettate:

55373
55494
67611
61633
09033
99.757
95.944
22808
65622
22161

Uscite non accettate:

55555
77787
85855
12345
99.233
12131
ABCDE
5033

Casi di test più accettabili sono disponibili a questo link pastebin .

Questi sono stati realizzati con questo programma Python:

importazione casuale
per i nella gamma (100):

    if random.randint (0,100)> = 50: #Metti la coppia toccando all'inizio se vera
        temp = [] #working array
        temp.append (random.randint (0,9)) #appEND cifra casuale
        temp.append (temp [0]) # aggiunge nuovamente la stessa cifra

        x = random.randint (0,9)
        mentre x == temp [0]:
            x = random.randint (0,9)
        temp.append (x) # aggiunge un'altra cifra univoca

        y = random.randint (0,9)
        mentre y == temp [0] o y == temp [2]:
            y = random.randint (0,9)
        temp.append (y) # aggiunge un'altra cifra univoca e la precedente cifra univoca
        temp.append (x)

    altro: #Metti la coppia toccante alla fine
        temp = [] #working array  
        temp.append (random.randint (0,9)) #appEND cifra casuale

        # Anche se non unico, riprova
        x = random.randint (0,9)
        mentre x == temp [0]:
            x = random.randint (0,9)
        temp.append (x) # aggiunge un'altra cifra univoca


        temp.append (temp [0]) # aggiunge nuovamente la stessa 0a cifra


        y = random.randint (0,9)
        mentre y == temp [0] o y == temp [1]:
            y = random.randint (0,9)
        temp.append (y) #appende un'altra cifra univoca due volte
        temp.append (y)

    tempstr = ""
    per i in temp:
        tempstr + = str (i)
    stampa tempstr

Questo è , quindi vince la risposta più breve in byte!


5
Suggerisco "Uscite possibili (probabilità> 0)" e "Uscite non possibili (probabilità = 0)" piuttosto che "Verità" e "Falsia" —questo sembra più in linea con ciò che penso tu stia chiedendo (e con il Python ).
Khuldraeseth na'Barya,

9
Dobbiamo stampare un output come 09033 con uno zero iniziale?
xnor

3
Se la probabilità è uniforme, puoi specificarla nella domanda. Per impostazione predefinita, randomnon significa uniformemente così
Jo King

3
forse aggiungere 99233, per capire da conveniewnce
l4m2

3
Benvenuti in PPCG! Bella prima sfida.
Jonathan Allan,

Risposte:


21

05AB1E , 11 byte

žh.r3£ûÁÂ)Ω

Provalo online!

Spiegazione

ž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

Mi chiedo se Emigna ha ... veda la risposta più alta +1.
Magic Octopus Urn

9

CJam (16 byte)

YmrG*98+ZbA,mrf=

Demo online

Nota: ho assunto che per OP "unico" significhi davvero "distinto".

Anche per 16 byte:

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

Dissezione

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"

Le altre varianti generano utilizzando [1 0 1 2 2]e quindi selezionare il risultato o il suo contrario.


9

Perl 5 , 81 63 56 byte

Taglia 7 byte con l'ispirazione di @DomHastings

Costruire il numero dal modello appropriato.

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

Provalo online!


Perl 5 , 89 byte

Seleziona numeri casuali a 5 cifre fino a quando non trova quello che soddisfa i criteri.

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

Provalo online!


Bel trucco usando i tasti hash per casualità! Penso che questo sia equivalente a -8, anche se potrei aver perso un caso limite ... Provalo online!
Dom Hastings,

1
Hash randomization. Brillante! più breve
Ton Hospel

La domanda è se time%2sia sufficientemente casuale, poiché è, in un certo senso, sotto il controllo dell'utente.
Xcali

@Xcali Sembra essere d'accordo che vada bene finché lo usi solo una volta, quindi penso che dovresti essere bravo.
FryAmTheEggman

8

Python 2 , 80 byte

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

Provalo online!

Emette un elenco di cifre.

Python 2 , 83 byte

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

Provalo online!

L'output è un numero.


Se la casualità non uniforme è consentita per impostazione predefinita (la domanda non specifica), puoi salvare byte anche campionando l'inversione: provala online! Modifica: non importa, vedo l'uniformità è stata modificata nelle specifiche. Mi chiedo se questo approccio possa ancora essere recuperato.
xnor

7

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

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

Provalo online!

Se è accettabile generare i numeri sempre nello stesso formato, questo può essere ridotto a 12 byte, o 1⌽1↓,∘⌽⍨3?10o 3⌽1↓,∘⌽⍨3?10.

Salvato un byte rimuovendo il superfluo .

Salvataggio di un byte grazie a H.PWiz e quindi altri 2 byte grazie al loro suggerimento.

Salvato un byte grazie a ngn.

La funzione assume ⎕IO←0( I ndex O rigin ).


Come?

(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. (30=3; 31=1.)
                    This yields either 1 1 2 3 2 or 2 3 2 1 1.

Non è possibile fornire
input

@drham non c'è input per la funzione. In questo caso, il campo TIO Inputviene utilizzato per chiamare la funzione g. Inoltre, g←non viene conteggiato nel conteggio dei byte perché non è necessario, viene utilizzato solo per chiamare la funzione.
J. Sallé,

Il fatto che gviene chiamato nella sezione input è solo una stranezza di come APL è impostato per funzionare su TIO
H.Pwiz

(4∨?2)salva un byte sopra1 4[?2]
H.Piz

1
È inoltre possibile salvare byte non assegnando fe utilizzando un treno. Te lo lascio comunque :)
H.Piz

6

Java 8, 145 136 125 119 byte

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

-9 byte grazie a @ OlivierGrégoire.
-11 byte grazie a @RickHitchcock .
-6 byte grazie a @Nevay .

Spiegazione:

Provalo 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


@ OlivierGrégoire Hai pubblicato questo alla sfida corretta? ..: S Sembra familiare, ma non è certo questa sfida ..
Kevin Cruijssen

La cosa amara ha rotto il mio collegamento ... Comunque, ecco il golf:v->{String r="";for(;!r.matches("(.)\\1(.).\\2|(.).\\3(.)\\4")|r.chars().distinct().count()!=3;r=(int)(Math.random()*1e5)+"");return r;}
Olivier Grégoire

1
Penso che il tuo regex possa essere abbreviato (.).*\\1(.).*\\2, risparmiando 11 byte.
Rick Hitchcock,

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

5

Gelatina , 23 byte

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

Provalo online!


Bene

7
@drham :) grazie. dovresti essere in grado di farlo presto, una volta che la maggior parte dei membri attivi si svegliano la tua domanda probabilmente riceverà molti voti. buona prima sfida e benvenuto a PPCG a proposito!
HyperNeutrino

5

Gelatina , 12 11 byte

ØDẊ⁽0yṃ,U$X

Provalo online!


Spiegazione


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

(*) L'argomento giusto di è l'elenco ['0','1','2',...,'9'], mischiato casualmente, con 10 elementi. Quindi il numero 13122verrà convertito nella base 10 ( [1,3,1,2,2]) biiettiva e indicizzato nella lista (quindi se la lista è l, il valore di ritorno dell'atomo è [l[1],l[3],l[1],l[2],l[2]], dove Jelly usa l'indicizzazione basata su 1)


(stessa idea della risposta 05AB1E, elaborata in modo indipendente)
user202729

... 05AB1E ottiene 6 voti a causa della possibilità di legare Jelly, Jelly ottiene solo 2 voti a causa della sua incapacità di vincere 05AB1E?
user202729

2
ho votato a favore della tua risposta. -> SPEECH 100 <---
L_Church

4

JavaScript (ES6), 79 byte

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

Provalo online!

Come?

Math.random()dà un float casuale in [0..1) . Usiamo +fper forzare la coercizione a una stringa. Ignoriamo lo zero iniziale e il punto decimale facendo [,,( assegnazione destrutturante dei primi due caratteri a nulla) e raccogliamo le prime 4 cifre decimali in d , a , b e c .

Se a , b e c sono 3 interi distinti, si costruisce il risultato finale sia AABCB o BCBAA formato (utilizzando la parità d decidere). Altrimenti, riproviamo fino a quando non lo sono.

Nel caso altamente improbabile di Math.random()restituire un valore senza sufficienti cifre decimali, almeno c verrà impostato su un carattere non cifra, costringendo il test a fallire e la chiamata ricorsiva. Se a , b e c sono interi validi allora d è garantito per essere un numero intero valido e, quindi questo non ha bisogno di essere testati.


Entrambi &&possono essere &. Inoltre, come [,,a,b,c,d]funziona? Non ho mai visto un input come [,,prima.
Kevin Cruijssen,

1
@KevinCruijssen Un bit-bit AND fallirebbe per esempio a=4, b=2, c=1perché 4-2&4-1&2-1 == 2&3&1 == 0. Ho aggiunto una breve spiegazione sull'assegnazione delle variabili.
Arnauld

Ah certo. Ho appena provato &&a &TIO e mi ha dato output corretti, quindi ho pensato che fosse possibile. Non ho realizzato &invece di &&filtrare output altrimenti validi. E grazie per la spiegazione aggiunta sull'incarico destrutturante, mai visto prima.
Kevin Cruijssen,

Questo è semplicemente fantastico +1
Luis felipe De jesus Munoz


2

Sporco , 33 byte

Utilizza il --numeric-outputflag in modo che sia leggibile, altrimenti genererebbe una stringa di caratteri di controllo con punti di codice corrispondenti alle cifre.

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

Provalo online!

Ha spiegato:

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

2

Carbone , 34 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

  χ                                 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
             I                      Cast array elements to string
            ↑                       Make array print horizontally
                                ²   Literal 2
                               ‽    Random element from implicit range
                              ¿     If
                                 ‖  Reflect

2

Retina , 40 byte


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

Provalo online!

Può stampare stringhe con zeri iniziali.

Spiegazione


10*

Inizializza la stringa su 10 caratteri di sottolineatura.

Y`w`d

Trascrivere ciclicamente i caratteri delle parole in cifre. Questo è un po 'strano. I we dsono abbreviati per le seguenti stringhe, rispettivamente:

w: _0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
d: 0123456789

La traslitterazione ciclica significa che prima, entrambe le stringhe vengono ripetute per la lunghezza del loro LCM:

_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_012345...
0123456789012345678901234567890123456789012345678901234567890123456789...

Poiché le lunghezze di stringa 53 e 10 sono coprimi, ogni copia di _è accoppiata con una cifra diversa. E ora traslitterazione ciclico sostituirà l' i esimo copia del _con l' i esimo accoppiamento in tale elenco espanso. Quindi finiamo con la seguente stringa:

0369258147

Tutto ciò per salvare un singolo byte sulla stringa letterale 0369258147 , quindi immagino? : D

Comunque, ora abbiamo una stringa di tutte e 10 le cifre.

V?`

Questo mescola le cifre. Quindi le prime tre cifre saranno una selezione uniformemente casuale di tre cifre distinte.

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

Abbiniamo la stringa ...ABCe la trasformiamo in BABCC. Il modo in cui lo facciamo è un po 'folle e salva di nuovo solo un byte rispetto a un approccio più semplice. Per prima cosa abbiniamo tutte le coppie di caratteri sovrapposte ( v), catturando la seconda ( .(.)). Poi ci riserviamo solo l'8 ° incontro ( 7zero-based), che è ABin ...ABC. Quindi lo sostituiamo ( $) con: B( $1), ABC( $<'che è il suffisso del separatore di corrispondenza a sinistra della corrispondenza), C( $'che è il suffisso della corrispondenza stessa).

O?`...?

Infine, abbiniamo 3 o 2 personaggi e mescoliamo le partite, dandoci una BABCCo CCBABa caso.


2

R , 78 byte

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

Provalo online!

sampleraccoglie 3 valori casuali da 0:9, che sono immessi in un vettore in questo modo: a b a c c. Ora abbiamo una probabilità 50/50 di invertire questo vettore, quindi concatenare e stampare.


Molto bella! 62 byte ; sembra che tu sia un po 'fuori allenamento;)
Giuseppe

Ho provato a usare rt, ma per qualche ragione ho pensato che fosse più lungo ....
JAD

E il (no-op è una buona scoperta :)
JAD

@Giuseppe il tuo asnwer può essere golfato ulteriormente a 55 byte ... TIO
JayCe

2

PHP, 73 72 66 byte

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

Modificare: 66 byte grazie al suggerimento di @David.

Provalo online!



@David Purtroppo la tua soluzione viola la regola 5. Potrebbe essere come rand(0,3).rand(4,6).rand(7,9), ma poi non è "uniformemente casuale". Btw. Non avevo familiarità rand()%2, quindi il tuo commento mi ha aiutato a migliorare leggermente la mia soluzione comunque.
retrowaver

1
ah, sì, hai ragione. Non ho visto quella regola. Ho uno che funziona oggi, a 66 byte: <?=strtr(rand()%2?AABCB:BCBAA,ABC,join(array_rand(range(0,9),3)));. È possibile verificare che il array_randsecondo parametro restituisca solo risultati univoci qui (testato oltre 10000 iterazioni).
Davіd

@ Grazie David, ho appena aggiornato il mio post!
Retròver

1

Rosso , 147, 146 125 byte

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

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



1

Python 3 + numpy, 69 byte

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

Spiegazione

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

1

C (gcc) , 126 119 byte

-6 byte da @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);}

Provalo online!


0

J , 35 byte

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

Provalo online!

Sono sicuro che può essere giocato molto più a lungo.

Spiegazione:

  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
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.