轻松记住数字

41

容易记住但理论上不易制作的数字

您面临的挑战是用任何一种语言生成符合以下条件的统一随机数的程序/功能：

  1. 长度为5位数字

  2. 有两个单独的重复数字对

  3. 一组重复的数字位于开头或结尾，并且数字彼此相邻

  4. 奇数被另一对数字包围

  5. 两个数字对和另一个数字应该都是唯一的

  6. 您的程序可以自行决定是否支持带前导零的数字。如果支持前导零，则必须将其包括在输出中：06088，而不是6088。如果不支持前导零，则根本不应生成诸如06088的数字。

测试用例

接受的输出：

55373
55494
67611
61633
09033
99757
95944
22808
65622
22161

不接受的输出：

55555
77787
85855
12345
99233
12131
abcde
5033

在此pastebin链接中可以找到更多可接受的测试用例。

这些是用这个python程序制作的：

随机导入
对于我在范围（100）中：

    如果random.randint（0,100）> = 50：＃将对在开始时接触如果为true
        temp = []＃工作数组
        temp.append（random.randint（0,9））＃附加随机数字
        temp.append（temp [0]）＃再次追加相同的数字

        x = random.randint（0,9）
        而x == temp [0]：
            x = random.randint（0,9）
        temp.append（x）＃附加另一个唯一数字

        y = random.randint（0,9）
        而y == temp [0]或y == temp [2]：
            y = random.randint（0,9）
        temp.append（y）＃附加另一个唯一数字，以及前一个唯一数字
        temp.append（x）

    否则：＃在末尾放置触摸对
        temp = []＃工作数组  
        temp.append（random.randint（0,9））＃附加随机数字

        ＃虽然不唯一，请重试
        x = random.randint（0,9）
        而x == temp [0]：
            x = random.randint（0,9）
        temp.append（x）＃附加另一个唯一数字


        temp.append（temp [0]）＃再次追加相同的第0位数字


        y = random.randint（0,9）
        而y == temp [0]或y == temp [1]：
            y = random.randint（0,9）
        temp.append（y）＃追加另一个唯一数字两次
        临时附加（y）

    tempstr =“”
    对我而言：
        tempstr + = str（i）
    打印模板

这是代码高尔夫球，因此最短答案以字节为单位！

code-golf  number  random 
— 德伦
source
5
我建议使用“可能的输出（概率> 0）”和“不可能的输出（概率= 0）”，而不是“真”和“虚假”，这似乎更符合我的要求（以及Python） ）。
— Khuldraeseth na'Barya
9
我们是否必须打印带有前导零的输出如09033？
— xnor
3
如果概率是均匀的，可以在问题中指定该概率。默认情况下，random并非统一表示
— Jo King
3
也许添加99233，以便于理解
— l4m2
3
欢迎来到PPCG！不错的第一个挑战。
— 乔纳森·艾伦，

Answers:

21

05AB1E，11个字节

žh.r3£ûÁÂ)Ω

在线尝试！

说明

ž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
— 艾米尼亚
source
我不知道Emigna ha ... 看到的答案是 +1。
— 魔术章鱼缸
9

CJam（16字节）

YmrG*98+ZbA,mrf=

在线演示

注意：我假设“独特”的OP确实意味着“与众不同”。

同样对于16个字节：

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

解剖

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"

其他变体使用生成[1 0 1 2 2]，然后选择结果或其反向。

— 彼得·泰勒
source
9

Perl 5中，81个 63 56字节

从@DomHastings获得灵感减少7个字节

从适当的模式构造数字。

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

在线尝试！

Perl 5，89个字节

随机选择5位数字，直到找到一个符合条件的数字。 

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

在线尝试！

— Xcali
source
使用哈希键获得随机性的好技巧！我认为这等效于-8，尽管我可能错过了一个小巧的案例... 在线尝试！
— Dom Hastings
1
哈希随机化。辉煌！较短
— Ton Hospel'3
问题是time%2，从某种意义上说，它是否在用户的控制之下是足够随机的。
— Xcali
@Xcali似乎已经达成共识，只要您只使用一次就可以了，所以我认为您应该很好。
— FryAmTheEggman
8

Python 2，80个字节

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

在线尝试！

输出数字列表。

Python 2，83个字节

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

在线尝试！

输出是一个数字。

— ovs
source
如果默认情况下允许非均匀随机性（问题未指定），您还可以通过采样反转来节省字节：在线尝试！编辑：没关系，我看到统一性已被编辑为规范。我想知道这种方法是否仍然可以挽救。
— xnor
7

APL（Dyalog Unicode），22 21 20 18 17字节

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

在线尝试！

如果始终以相同格式输出数字是可以接受的，则可以将其缩短为12个字节（1⌽1↓,∘⌽⍨3?10或）3⌽1↓,∘⌽⍨3?10。

通过删除不必要的字节节省了一个字节∘。

多亏了H.PWiz，保存了一个字节，由于提示，又节省了2个字节。

多亏了ngn，节省了一个字节。

该函数假设⎕IO←0（I dex O rigin）。

怎么样？

(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.
— J·萨莱
source
无法提供输入
— Drham
@drham该功能没有输入。在这种情况下，TIO字段Input用于调用函数g。另外，g←由于字节数不是必需的，因此不计入字节数，它仅用于调用函数。
— J.Sallé18年
这一事实g被称为输入部分仅仅是一个APL是如何设置对TIO运行怪癖
— H.PWiz
(4∨?2)节省了一个字节1 4[?2]
— H.PWiz
1
您还可以通过不分配f和使用火车来节省字节。我会留给你:)
— H.PWiz
6

爪哇8，145个 136 125 119字节

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

-9个字节，感谢@OlivierGrégoire。
-11个字节感谢@RickHitchcock。
-6个字节，感谢@Nevay。

说明：

在线尝试。

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
— 凯文·克鲁伊森
source
— OlivierGrégoire18年
@OlivierGrégoire你在正确的挑战发布此..：2 S它看起来很熟悉，但它肯定不是这个挑战..
— 凯文Cruijssen
那个棘手的事情打断了我的联系……无论如何，这是高尔夫：v->{String r="";for(;!r.matches("(.)\\1(.).\\2|(.).\\3(.)\\4")|r.chars().distinct().count()!=3;r=(int)(Math.random()*1e5)+"");return r;}
— 奥利维尔·格雷戈雷（OlivierGrégoire）
1
我认为您的正则表达式可以缩短为(.).*\\1(.).*\\2，节省11个字节。
— 里克·希区柯克
1
119个字节：v->{String r;for(;!(r=(int)(Math.random()*1e5)+"").matches("((.).?\\2){2}")|r.chars().distinct().count()<3;);return r;}
— Nevay
5

果冻，23个字节

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

在线尝试！

— 超中微子
source
不错，我会投票，但我不能
— drham
7
@drham :)谢谢。您应该能够很快，一旦最活跃的成员唤醒您的问题，就可能获得很多支持。很好的第一个挑战，欢迎来到PPCG！
— HyperNeutrino
5

果冻，12 11字节

ØDẊ⁽0yṃ,U$X

在线尝试！

说明


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

（*）的正确参数ṃ是list ['0','1','2',...,'9']，随机洗牌，有10个元素。因此，数字13122将转换为双射基数10（[1,3,1,2,2]）并索引到列表中（因此，如果列表为l，则原子的返回值为[l[1],l[3],l[1],l[2],l[2]]，其中Jelly使用基于1的索引）

— 用户名
source
（与05AB1E答案的想法相同，是独立提出的）
— user202729
... 05AB1E因为能够打结果冻而获得6票赞成，而Jelly因为无法赢得05AB1E而仅获得2赞成票？
— user202729
2
我支持你的回答。-> SPEECH 100 <---
— L_Church
4

JavaScript（ES6），79个字节

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

在线尝试！

怎么样？

Math.random()给出[0..1）中的随机浮点数。我们+f用来强迫字符串。我们这样做会忽略前导零和小数点[,,（将前两个字符的分配破坏为空），并将前四个十进制数字收集到d，a，b和c中。

如果a，b和c是3个不同的整数，我们将以AABCB或BCBAA格式（使用d的奇偶性决定）构建最终输出。否则，我们会再试一次，直到出现问题为止。

在极不可能的情况下，Math.random()返回一个没有足够小数位数的值，至少会将c设置为非数字字符，从而迫使测试失败并进行递归调用。如果a，b和c是有效整数，则d也保证是有效整数，因此不需要测试该整数。

— Arnauld
source
两者&&都可以&。另外，如何[,,a,b,c,d]运作？我从未见过像[,,以前这样的输入。
— 凯文·克鲁伊森
1
@KevinCruijssen一个按位AND会失败，例如a=4, b=2, c=1因为4-2&4-1&2-1 == 2&3&1 == 0。我添加了有关变量赋值的简短说明。
— Arnauld
嗯当然了 我只是试图&&以&在TIO，它给了正确的输出，所以我认为这是可能的。没有意识到&而不是&&会过滤掉有效的输出。并且感谢您对销毁分配的额外说明，这是以前从未见过的。
— 凯文·克鲁伊森
这真是太棒了+1
— Luis felipe De jesus Munoz
2

脏，33个字节

使用该--numeric-output标志以便可读，否则将输出一串控制字符，其代码点与数字相对应。

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

在线尝试！

解释：

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
— 巨大
source
2

木炭，34字节

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

在线尝试！链接是详细版本的代码。说明：

  χ                                 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
— 尼尔
source
2

视网膜，40字节


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

在线尝试！

可以打印带有前导零的字符串。

说明


10*

将字符串初始化为10下划线。

Y`w`d

将单词字符循环音译为数字。这有点奇怪。在w和d短以下字符串，分别为：

w: _0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
d: 0123456789

循环音译意味着首先，两个字符串都重复到其LCM的长度：

_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_012345...
0123456789012345678901234567890123456789012345678901234567890123456789...

由于字符串长度53和10是互质的，因此的每个副本_都与不同的数字配对。现在循环音译将取代我个拷贝_与我个配对在展开的列表。因此，我们以以下字符串结尾：

0369258147

所有这些都是为了在文字字符串上保存一个字节0369258147，所以，我猜是吗？：D

无论如何，我们现在有了一个全十位数的字符串。

V?`

这会使数字混乱。因此，前三个数字将是三个不同数字的一致随机选择。

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

我们匹配字符串...ABC并将其转换为BABCC。但是，与更直接的方法相比，我们这样做的方式有点疯狂，并且仅节省了一个字节。我们首先匹配所有重叠（v）对的字符，捕获第二个（.(.)）。然后，我们仅保留in中的第8个匹配项（7基于零）。然后我们将（）替换为：（），（这是比赛左侧的match- 分隔符的后缀），（这是比赛本身的后缀）。AB...ABC$B$1ABC$<'C$'

O?`...?

最后，我们匹配3个或2个字符，并随机排列匹配项，BABCC或者CCBAB随机给我们。

— 马丁·恩德
source
2

R，78个字节

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

在线尝试！

sample从中选择3个随机值0:9，将其放置在矢量中，如下所示：a b a c c。现在我们有50/50的机会反转此向量，然后进行连接和打印。

— 贾德
source
非常好！62个字节 ; 看起来您有点不习惯；）
— Giuseppe
我看了看使用rt，但由于某些原因，我认为这是长....
— JAD
而(as no-op是个不错的发现：)
— JAD
@Giuseppe，您的附加对象可以打到55字节以上…… TIO
— JayCe
2

PHP，73 72 66字节

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

编辑： 66字节感谢@David的建议。

在线尝试！

— 逆向摇动
source
— Davіd
@David不幸的是，您的解决方案违反了规则5。它可能像rand(0,3).rand(4,6).rand(7,9)，但是又不是“均匀随机”的。顺便说一句。我不熟悉rand()%2，因此无论如何您的评论帮助我略微改善了解决方案。
— retrowaver
1
啊，是的，你是对的。我没有看到那个规则。我有一个现在可以工作的文件，为66个字节：<?=strtr(rand()%2?AABCB:BCBAA,ABC,join(array_rand(range(0,9),3)));。您可以在此处测试array_rand的第二个参数仅返回唯一结果（经过10000次迭代测试）。
— Davіd
@David谢谢，刚刚更新了我的帖子！
— retrowaver
1

红色，147，146125字节

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

在线尝试！

取消高尔夫：

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 
]
— 加伦·伊万诺夫（Galen Ivanov）
source
1

Python 3 + numpy，69个字节

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

说明

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
— 用户名
source
1

C（GCC） ，126个 119字节

@ceilingcat的-6个字节

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

在线尝试！

— 瓦兹特
source
0

J，35个字节

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

在线尝试！

我相信它可以打得更远。

说明：

  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
— 加伦·伊万诺夫（Galen Ivanov）
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.