里恩数


38

Champernowne常数是通过串联第一个n数字而n趋于无穷大而构成的数字。看起来像这样:

0.123456789101112131415161718192021222324252627282930...

现在,我将向您介绍里恩号码。可以将Champernowne常数的最小值视为一个整数。我将第一个数字的Rien号码n称为Ri(n)。这是如何制定的:

  1. 第一个n自然数(序列{1,2,3,...})是连接在一起的。
  2. 然后根据数字值对该结果进行排序。这样1..12会看起来像011111223456789
  3. 由于Rien数不能有前导零,因此我们将所有0s 移到有效的位置,同时使数保持最小,从而得出101111223456789。这是Ri(n),在这种情况下是Ri(12)。

以下是Ri(n)的一些结果:

Ñ     日(Ñ)
1 1
2 12
3 123
7 1234567
9 123456789
10 10123456789
15 101111111223344556789
34 10001111111111111222222222222223333333334444555555666777888999
42 100001111111111111122222222222222233333333333333444444444455556666777788889999
45 100001111111111111122222222222223333333333333344444444444444555556666777788889999
55 10000011111111111111122222222222222223333333333333333444444444444444444455555555555566666777778888899999
100 100000000000111111111111111112212222222222222222233333333333333333333444444444444444444444555555555555555555555666666666666666666667777777777777777777888888888188888888888899999999999999999999
99910000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111122222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222233333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333344444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444455555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555566666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666677777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777788888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888899999999999999999999999999999999999999999999999999999999999999999999999999999999

目标假定n输入1≤ <10000(通过自变量,STDIN或硬编码,如果您的语言不支持常规输入),则输出/返回Ri(n)。

这是一个,因此以字节为单位的最短代码获胜。您可以使用在比赛后制作的语言,但前提是该语言不是用来回答此挑战的。(当然,如果它提供了一种有趣的解决方案,则可以使用它,但是将您的答案标记为不竞争。)

参考实施

我在IE中对此进行了测试,因此实际上应该没有问题。如果有一个问题,有一个简单的解决方案:让一个理智的浏览器。

function min(n) {
  var seq = [];
  for(var i = 1; i <= n; i++) seq.push(i);
  seq = seq.join("").split("").map(Number);
  var to;
  if(seq.indexOf(1) >= 0) to = seq.splice(seq.indexOf(1), 1);
  seq.sort(function(a, b) {
    return a - b;
  });
  if(to) seq = to.concat(seq);
  return seq.join("");
}
t.onchange = t.onkeyup = function() {
  h.innerHTML = min(this.value)
}
* {
  font-family: Consolas, monospace;
}
input {
  border: 2px dotted #aaaaaa;
  border-radius: 5px;
  margin: 10px;
}
<input id="t" type="number">
<div id="h">


排行榜

这篇文章底部的Stack Snippet会根据答案a)生成目录,a)作为每种语言最短解决方案的列表,b)作为整体排行榜。

为确保您的答案显示出来,请使用以下Markdown模板以标题开头。

## Language Name, N bytes

N您提交的文件大小在哪里。如果您提高了分数,则可以将旧分数保留在标题中,方法是将它们打掉。例如:

## Ruby, <s>104</s> <s>101</s> 96 bytes

如果要在标头中包含多个数字(例如,因为您的分数是两个文件的总和,或者您想单独列出解释器标志罚分),请确保实际分数是标头中的最后一个数字:

## Perl, 43 + 2 (-p flag) = 45 bytes

您还可以将语言名称设置为链接,然后该链接将显示在代码段中:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes


22
我一直以为0里恩号码。
瑕疵的

不知道我是否缺少某些东西,但是我们可以将1s 之一移到s前面0,是吗?
FryAmTheEggman'1

@FryAmTheEggman你是正确的。
科纳·奥布莱恩

@MartinBüttner\ o /您找到了它。
科纳·奥布莱恩

@CᴏɴᴏʀO'Bʀɪᴇɴ不,那不一样。那只允许整个数字的排列,而不是单个数字的排列。
Martin Ender'1

Answers:



13

Perl,44 42 41 33 31字节

Yaaay,有史以来第一篇文章!

感谢primo节省了2个字节。

print 1,sort"@{[2..<>]}"=~/\d/g

就像其他人一样,删除1并在其前面手动添加即可完成工作。

在线尝试


2
欢迎来到PPCG,并祝贺您的​​第一篇文章(尽管让我欢迎您似乎很奇怪,因为您在我之前就加入了...)。两件事-我占了43个字节 ...第二,您的“在线试用”链接看起来指向您的代码的旧版/其他版本。手动将代码复制粘贴到Ideone中有效,但您的链接无效。
AdmBorkBork

谢谢您的评论!我使用TextWrangler来计算字节数,猜想我走了1个太远了……(再加上一个空格,这样可以将整个字节数减少到42)。Ideone现在应该修复。
保罗·皮卡德

哦,不知道那件事。在Mac(5.18)上的Perl上也可以使用。谢谢!
保罗·皮卡德

5
划掉的

2
摆脱了分割/ print 1,sort"@{[2..<>]}"=~/\d/g
合并,

11

Japt,14 12字节

1+2o°U ¬¬n ¬

在线尝试!

这个怎么运作

1+2o°U ¬¬n ¬  // Implicit: U = input integer
  2o°U        // Generate the range of integers from 2 to U, inclusive.
       ¬¬     // Join, then split into chars.
         n    // Sort.
1+         ¬  // Join again, and add a 1 to the beginning.
              // Implicit: output last expression

4
o_o您在5分钟的宽限期内打了高尔夫球吗?西部最快的枪
Conor O'Brien

@CᴏɴᴏʀO'Bʀɪᴇɴ我猜你不想在那之后发布新的代码高尔夫:D
Pierre Arlaud

9

视网膜,78字节

是时候炫耀一些新的Retina功能了(它仍然没有什么竞争力,但是在今天之前,它可能已经接近300字节)。

.+
$0$*1
\B
 $`
(1)+
$#1
^1| 

.
 1$0$*1
+r`(1+\2) (1+)\b
$2 $1
 1(1)*
$#1
^
1

在线尝试。

说明

虽然现在可以很方便地在十进制和一进制之间进行转换,但是这仍然很长,因为我必须来回转换几次,因为某些操作在十进制中比在一进制中更可行,反之亦然。

.+
$0$*1

让我们开始将输入转换为一元。这是通过匹配输入然后使用$*1它重复1多次(此重复功能是今天的新功能)而起作用的。

\B
 $`

接下来,我们生成一元1到的范围N。我已经在FizzBu​​zz答案中解释了为什么这样做有效。

(1)+
$#1

我们将范围内的每个数字转换回十进制,以便可以使用十进制数字。这是通过匹配每个一元数来完成的,以便每个都1生成一个单独的捕获。然后,使用新的捕获计数语法将其替换为第一组的捕获数量$#1

^1| 

这会删除1字符串中的前导以及所有空格,因此只剩下数字(单个除外1)。

.
 1$0$*1

我们转换回一元并添加1到每个数字(以确保偶数0是非空的)。我们还在每个数字的前面插入一个空格,以确保将它们分开。

+r`(1+\2) (1+)\b
$2 $1

我们反复匹配一个小数字,然后匹配一个大数字,然后交换它们。视网膜中的气泡排序。:)

 1(1)*
$#1

Aaa和返回十进制。

^
1

最后,我们1在前面插入一个,以说明我们之前删除的那个。


1
你们说什么新功能?
科纳·奥布莱恩

1
@CᴏɴᴏʀO'Bʀɪᴇɴ我待会再添加解释。此代码使用新的替换语法来计数捕获次数和重复字符,可用于合理的短十进制/一元转换。这是完整的变更
Martin Ender

@MartinBüttner很好。这是否意味着Retina不再可以要求此项豁免
Digital Trauma'1

@DigitalTrauma我认为它仍然是最自然的输入形式。我也从未理解过这种语言主义如何在该站点上获得如此多的支持。
Martin Ender'1

6

Haskell,44个字节

import Data.List
f n='1':sort(show=<<[2..n])

不幸的sortData.List,这是17个字节!


6

JavaScript(ES6),65 62 54 52字节

由于edc65,节省了3个字节

x=>eval("for(b='';x>1;)1+[...b+=x--].sort().join``")

构建一个从2到的所有数字的字符串x,然后拆分,排序,联接并在开头添加1。这可能仍然可以打高尔夫球;建议欢迎!


我手头没有ES6,但您不能只使用(新)Array(x-1).map((_,y)=>y+2)吗?
科纳·奥布莱恩

@CᴏɴᴏʀO'Bʀɪᴇɴ映射会跳过空数组元素,因此您应该使用Array(n).fill().map(...(请参阅ES6技巧)
edc65 2016年

太晚了,无法发布我的消息,但对您来说是个提示:(n=>1+[...[...Array(n-1)].map(_=>++n,n=1).join``].sort().join`` 短1个字节,这是拆分的内容)
edc65

@ edc65和CᴏɴᴏʀO'Bʀɪᴇɴ感谢您的提示!我想知道为什么使用.split()感觉如此奇怪……
ETHproductions 2016年

@ edc65 h,我的解决方案与您的解决方案一样长吗?n=>1+[...[...Array(n+1).keys()].slice(2).join``].sort().join``
Neil



4

APL(17)

'1',∆[⍋∆←1↓∊⍕¨⍳⎕]

说明:

'1',∆[⍋∆←1↓∊⍕¨⍳⎕]
-----------------
               ⎕   read a number from the keyboard
               ⍳    get the natural numbers up to and including that number
             ⍕¨    get the string representation for each number
           ∊       flatten the array (giving a string of digits)
         1↓        remove the first digit (which is always 1)
       ∆←          store the result in ∆
      ⍋            get a permutation to sort ∆ upwards
    ∆[           ] rearrange ∆ so that it is sorted
'1',               add a 1 to the front

测试:

      '1',∆[⍋∆←1↓∊⍕¨⍳⎕]
⎕:
      1
1
      '1',∆[⍋∆←1↓∊⍕¨⍳⎕]
⎕:
      10
10123456789
      '1',∆[⍋∆←1↓∊⍕¨⍳⎕]
⎕:
      55
10000011111111111111122222222222222223333333333333333444444444444444455555555555566666777778888899999

真好!比我的好多了。:DI没有意识到那会弄平数组并给你一个字符串。很高兴知道。
Alex A.

3

Python 2,60个字节

_="".join;print"1"+_(sorted(_(map(str,range(2,input()+1)))))

3

ClojureScript,48个字节

#(apply str"1"(sort(apply str(range 2(inc %)))))

与所有其他相同,几乎一样。REPL 在这里可用。


3

Ruby,48个字节

匿名函数。基本上,这里只是Rubyfied的其他一些答案。

->n{n>1?(?1+[*2..n].join.chars.sort*'').to_i: n}

3

Brachylog76 41字节

1 .;{,1:.e?}?:1fcbZlL,ZoOlM,10^(L-M)=:Oc.

以数字作为输入。

该解决方案可以与我对内置Findall谓词所做的一些更改一起使用f。OP显然可以使用比答案更早的语言,所以我认为这很好(我很早以前就打算进行更改,由于这个挑战,我只是激励自己去做)。

说明

1 .                                            § If the input is 1, unify output with 1

   ;                                           § Else

    {      }?:1f                               § Output a list of all inputs which satisfy
                                               § the predicate in brackets with the input
                                               § of the main predicate (ie the input number)
                                               § as output

     ,1:.e?                                    § True if the input is an integer between 1
                                               § and . (the output)

                cbZ                            § Concatenate everything into a single number,
                                               § remove the first digit (1) and call it Z

                   lL,ZoOlM,                   § L is the length of Z, M is the length of O
                                               § O being Z sorted (which removes the leading
                                               § 0s)

                            10^(L-M)=:Oc.      § Concatenate 10^(L-M) at the beginning of O
                                               § and unify it with the output

3

Smalltalk,76个字节

和Smalltalk一样,概念上非常简洁,但文本上非常冗长...

f:l^'1',((2to:l)fold:[:p :q|p asString,q asString])asByteArray sort asString

将其添加为类方法,String并像这样调用,例如20String f: 20


3

Bash + GNU实用程序,58

seq $1|sed 's/./&\n/g'|sort|tr -d \\n|sed 's/\(0*\)1/1\1/'

在线尝试。


1
我有类似的方法,但是对“ 1开始”部分(52字节)的处理不同。与您一起,您可以剃光:sort(1位长,不需要-n)。
奥利维尔·杜拉克

3

Bash,35 34字节

printf %d 1`seq 2 $1|fold -1|sort`

这基于@DigitalTrauma@OlivierDulac的答案。与Ideone在线尝试。

这个怎么运作

  • seq 2 $1打印从2到命令行上指定的整数的所有整数。

  • fold -1 包装所有宽度为1的行,即,将每个字符放在其自己的行上。

    -1 似乎是一个未记录的功能。

  • sort 按字符的数值对其排序。

  • printf %d 1`...`​预先考虑一个1到第一行,并打印各行作为一个整数(%d),没有分离。

    这利用了Bash好奇的printf实现的优势,该实现一遍又一遍地重复格式字符串,直到消耗完所有参数为止。


+1,我比我们更喜欢:)
Olivier Dulac

3

JavaScript ES6,49 46字节

感谢edc65 2字节

F=
x=>1+[...(g=_=>x>1?x--+g``:_)``].sort().join``

;console.log(F(15))


1
我有类似的东西,但短了1个字节。尝试使用不带参数的递归函数,只减小原始参数x
edc65

2

朱莉娅,33个字节

n->"1"*join(sort([join(2:n)...]))

这是一个lambda函数,它接受一个整数并返回一个字符串。要调用它,请将其分配给变量。

我们构造range 2:n,对于n<2,该范围将为空,将其连接到一个字符串中,将该字符串喷射到一个字符数组中,对其进行排序,将其连接到一个字符串中,并添加1。


2

APL,21字节

{' '~⍨⍕1,x[⍋x←⍕1↓⍳⍵]}

这是一个未命名的单子函数,它在右侧接受一个整数并返回一个字符串。要调用它,请将其分配给变量。

说明:

            x←⍕1↓⍳⍵]}   ⍝ Get the numbers 1:input, drop 1, convert to string
         x[⍋            ⍝ Sort
      ⍕1,               ⍝ Tack 1 onto the front, flatten to string
{' '~⍨                  ⍝ Remove the spaces (side effect of ⍕ on an array)

在线尝试


2

Python 2,60个字节

P=input();print"1"+"".join(sorted(`range(2,P+1)`)[P*2-4:-2])

为胜利建立索引。:-)


Python 2,60个字节

P=input();print"1"+"".join(sorted(`range(-P,-1)`))[P*3-5:-2]

只是一种选择。


2

银河1.6.4,22个字节(不竞争)

^^'LH=^^JB", "-Q"1";+!

我必须为此挑战添加一个排序操作码。


说明

^^                      ` pop the TOS
  '                     ` read input from the command line
   LH                   ` push a reversed Pythonic range(TOS+1)
     =^^J               ` remove the top 2 items from the TOS
         B              ` push the string literal of the TOS
          ", "-         ` remove ", " from the TOS
               Q        ` sort the TOS
                "1";+   ` add "1" to the beginning of the TOS
                     !  ` output the TOS

2

认真地,10个字节

,u2xεjS'1+

十六进制转储:

2c753278ee6a5327312b

在线试用

说明:

,            Read input
 u2x         Push range from 2..n
    εj       Join into string
      S      Sort
       '1+   Prepend a "1"

2

Bash和GNU工具,58 52字节

echo 1$(seq 2 $1|sed -e 's/./&\n/g'|sort|tr -d \\n)

与@ Digital-trauma类似的方法,但是加1的方式不同,并且-n不需要,因为数字是1位数字长。(我做了第一次尝试后就看到了他的回答)
Olivier Dulac

2

PowerShell,61 59字节

param($a)(("1"+-join([char[]]-join(2..$a)|sort)),1)[$a-eq1]

接受输入param($a),然后使用它来索引到数组[$a-eq1]。如果为true,则索引第二个元素并输出1。否则,我们将连接"1"由以下对象join创建的ed数组:1)定义一个2..$a本身已经被join一起编辑的新范围,2)将其强制转换为char数组,以及3)通过Sort-Objectcmdlet 发送,然后全部输出。

Edit1-通过移动内部-join运算符节省了2个字节。


2

Gogh9 7字节

GJT1-1P

您可以使用以下命令运行它:

$ ./gogh noi 'GJT1-1P' <input>

G     “ Push a range (1, TOS]       ”
J     “ Join the TOS                ”
T     “ Sort the TOS                ”
1-    “ Remove the first 1          ”
P     “ Prepend the TOS to the STOS ”

“您可以使用本次比赛后制作的语言,只要该语言不是用来回答此挑战的即可。” 我通常会允许这些语言在挑战中具有竞争力;)
Conor O'Brien

@CᴏɴᴏʀO'Bʀɪᴇɴ:太棒了!感谢您指出:)
扎克·盖茨

2

果冻,8 字节

RDFṢ1œ|Ḍ

在线尝试!

这个怎么运作

RDFṢ1œ|Ḍ  Main link. Argument: n (integer)

R         Range; yield r := [1, ..., n].
 D        Convert each k in r into the array of its digits in base 10.
  F       Flatten the resulting array of lists.
   Ṣ      Sort the resulting flat list of digits.
    1œ|   Perform multiset union with 1 as left argument.
          This moves a single 1 to the beginning of the list.
       Ḍ  Convert the resulting list of base 10 to integer.

2

的Oracle SQL 11.2 222个 211字节

SELECT 1||TRIM(xmlagg(xmlelement(e,c)).EXTRACT('//text()'))FROM(SELECT SUBSTR(s,LEVEL+2,1)c FROM(SELECT MAX(sys_connect_by_path(LEVEL,' '))s FROM DUAL CONNECT BY LEVEL<=:1)CONNECT BY LEVEL<=LENGTH(s)ORDER BY 1);

未打高尔夫球

SELECT 1||TRIM(xmlagg(xmlelement(e,c)).EXTRACT('//text()'))  -- add leading 1, concatenate each char and remove spaces
FROM   (
         SELECT SUBSTR(s,LEVEL+2,1)c                          -- split the string in characters, omiting the first number (1)   
         FROM   (
                  SELECT MAX(sys_connect_by_path(LEVEL,' '))s -- create a string by concatenating numbers
                  FROM   DUAL 
                  CONNECT BY LEVEL<=:1
                )
         CONNECT BY LEVEL<=LENGTH(s)ORDER BY 1
       )

2

MATL,17个字节

使用语言/编译器的当前版本(7.0.0)

49[]i:"@YUh]6L)Sh

FryTheEgggman的回答启发。

编辑(2016年7月29日):您可以在线进行尝试,并进行一些修改以符合语言的更改。

>> matl
 > 49[]i:"@YUh]6L)Sh
 >
> 12
101111223456789

说明

49        % push '1'
[]        % push empty array
i:        % input "N" and build vector [1, 2, ... N]
"         % for each number in this vector
   @      % push that number
   YU     % convert to string
   h      % concatenate horizontally
]         % end
6L)       % remove first element
S         % sort
h         % concatenate horizontally

1

05AB1E,6个字节

注意:此提交使用的功能会推迟挑战,因此没有竞争力

码:

Lß?J{?

说明:

L      # Creates the list [1 .. input]
 ß     # Extract the smallest value of the list
  ?    # Print this value (always 1)
   J   # ''.join(list)
    {  # Sort the string
     ? # Print this value

使用ISO 8859-1编码


这是如何运作的?
lirtosiast

@ThomasKwa添加了说明
Adnan

哇 这是太棒了!
科纳·奥布莱恩

1

Mathcad,86个“字节”

函数s(n)使用for循环,通过将每个数字转换成其字符串形式并将它们串联在一起来构建Champernowne“整数”。然后将字符串转换为其等效的ASCII码向量并进行排序。然后,该函数将所有前导零与第一个零交换,最后将向量转换回字符串。

为了检查功能,我将测试用例放入向量vn中,然后使用vectorize运算符将s应用于vn。然后,我根据给定的测试用例值检查结果。

在此处输入图片说明


Mathcad是基于2D工作表的数学应用程序,该工作表由“区域”组成,每个区域可以是文本,数学表达式,程序,绘图或脚本化组件。

从调色板工具栏中选取数学或编程指令,或使用键盘快捷键输入。为了打高尔夫球,将一个操作(“字节”)作为创建名称或表达式(例如,将变量a设置为3时,我们将编写a:= 3)所需的键盘操作数。 :=是单个按键“:”,a和3总共是3个“字节”。为操作员编程需要键入ctl-shft-#(或在编程工具栏上单击一下),因此再次等同于1个字节

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.