整数的旋转位置


20

挑战:

输入:

正整数的排序列表。

输出:

在将每个整数中的数字向左旋转其索引次数并再次对修改后的列表进行排序后,仍处于完全相同索引的整数数量。

例:

输入:[8,49,73,102,259,762,2782,3383,9217,37846,89487,7471788]
输出(基于0的索引):6
输出(基于1的索引):5

为什么?

基于0的索引:

After rotating each: [8,94,73,102,592,276,8227,3338,9217,63784,89487,7887471]
Sorted again:        [8,73,94,102,276,592,3338,8227,9217,63784,89487,7887471]

Input indices:        0  1  2   3   4   5    6    7    8     9    10      11
Original input-list: [8,49,73,102,259,762,2782,3383,9217,37846,89487,7471788]
Modified list:       [8,73,94,102,276,592,3338,8227,9217,63784,89487,7887471]
Modified indices:     0  2  1   3   5   4    7    6    8     9    10      11
Equal indices:        ^         ^                      ^     ^     ^       ^

So the output is: 6

基于1的索引:

After rotating each: [8,49,37,021,925,762,2278,3383,2179,37846,94878,8874717]
Sorted again:        [8,(0)21,37,49,762,925,2179,2278,3383,37846,94878,8874717]

Input indices:        1  2  3   4   5   6    7    8    9    10    11      12
Original input-list: [8,49,73,102,259,762,2782,3383,9217,37846,89487,7471788]
Modified list:       [8,21,37,49,762,925,2179,2278,3383,37846,94878,8874717]
Modified indices:     1  4  3  2   6   5    9    7    8    10    11      12
Equal indices:        ^     ^                               ^     ^       ^

So the output is: 5

挑战规则:

  • 确保输入列表仅包含正整数。
  • 确保输入列表从最低到最高排序。
  • 输入列表保证至少包含两个项目。
  • 正如您在上面看到的,基于0的索引和基于1的索引都是允许的。请在您的答案中说明您使用了哪两种,因为输出可能会有所不同!
  • 0旋转后的前导s被忽略,这可以从上面的基于1的示例中看到,其中整数在旋转后102变为021,然后被视为21
  • 整数在输入列表中保证是唯一的,并保证在轮换完成后保持唯一。
  • 请注意,我们仅查看与输入的位置相关的旋转整数的位置,而不查看与input-list的值相关的位置。为了弄清楚我的意思:在使用input-list [1234,3412]和基于1的索引时,列表[2341,1234]在旋转每个整数后变成其索引次数,然后在排序时变为[1234,2341]。尽管原始输入列表和旋转列表都在开头1234处都包含整数,但它们并不相同!旋转后12343412前。因此0,此输入列表的1索引输出为,因为两个整数交换了位置。
  • 输入是灵活的。可以是整数的列表/流/数组/字符串/数字数组等。如果您不将输入作为整数,请说明您使用的内容。

一般规则:

  • 这是,因此最短答案以字节为单位。
    不要让代码高尔夫球语言阻止您发布使用非代码高尔夫球语言的答案。尝试针对“任何”编程语言提出尽可能简短的答案。
  • 标准规则适用于具有默认I / O规则的答案,因此允许您使用STDIN / STDOUT,具有适当参数的函数/方法以及返回类型的完整程序。你的来电。
  • 默认漏洞是禁止的。
  • 如果可能的话,请添加一个带有测试代码的链接(即TIO)。
  • 另外,强烈建议为您的答案添加说明。

测试用例:

Input: [8, 49, 73, 102, 259, 762, 2782, 3383, 9217, 37846, 89487, 7471788]
0-based output: 6
1-based output: 5

Input: [1234, 3412]
0-based output: 2
1-based output: 0

Input: [2349, 2820, 17499, 21244, 29842, 31857, 46645, 56675, 61643, 61787]
0-based output: 3
1-based output: 0

Input: [4976, 11087, 18732, 22643, 52735]
0-based output: 2
1-based output: 3

Input: [4414, 5866, 7175, 8929, 14048, 16228, 16809, 19166, 24408, 25220, 29333, 44274, 47275, 47518, 53355]
0-based output: 4
1-based output: 4

Input: [11205, 16820, 63494]
0-based output: 1
1-based output: 3

随意使用此取消高尔夫的05AB1E程序生成更多随机测试用例(或从中获得启发),其中输入为随机列表的大小(注意:此生成器的输出可能不符合规则“在整数中保证整数是唯一的”)。输入列表,并保证在轮换完成后保持唯一 ”,因此在使用时请记住这一点。)


我们是否可以假设输入中至少包含2个元素?
罗宾·赖德

2
@RobinRyder Hmm,我的第一个想法是不会,但是由于我没有任何包含单个项目的测试用例,因此对挑战不会增加太多,为什么呢。我将添加一个规则,以确保输入列表至少包含2个项目。
凯文·克鲁伊森

我们可以接受输入作为字符串列表吗?
无知的体现

1
@Shaggy我已经通知了我认为将从中受益的答案。如果您发现也可以从中受益,请随时通知他们。
凯文·克鲁伊森

1
从该示例看来,输出应该是“仍在相同索引处的整数数量,将每个整数中的数字向左旋转其索引次数,然后再次对数组进行排序 ”?
qwr

Answers:


11

[R 114个 107字节

-5个字节,感谢Giuseppe。

Outgolfed通过digEmAll。

function(l){for(j in seq(l))l[j]=rep(l[j]%/%(e=10^(b=nchar(l[j]):1-1))%%10,j+1)[j+0:b]%*%e
sum(sort(l)==l)}

在线尝试!

0索引。

非高尔夫版本:

function(l) {
  n = length(l)                         # size of input
  for (j in 1:n) {  
    b = nchar(l[j]) -1                  # number of digits in l[j] -1
    e = 10 ^ (b:0) 
    d = l[j] %/% e %% 10                # convert to vector of digits
    l[j] = rep(d, j + 1)[j + 0:b] %*% e # rotate digits and convert back to an integer
  }
  sum(sort(l) == l)                     # number of integers which are in the same position
}

要按位置旋转b整数j,代码将数字重复多次,然后将位置的数字取j+1j+b。例如,要旋转1024次,请保留标记为x(位置5至7)的值:

102102102102
    xxx

所以结果是021



@Giuseppe谢谢!我需要记住seq(a=...)。我希望Map可以执行一些魔术操作,但是我的尝试最多不会使字节数保持不变。
罗宾·赖德

Map由于function样板至少为9个字节,可能有点太昂贵,但是如果您切换到0索引,我们可以做109个字节
朱塞佩

1
好发现!意识到只要输入至少包含2个元素(我问这是否还可以),它就seq(a=l)可以降至107 seq(l)
罗宾·赖德


6

05AB1E,9个字节

ΣN._ï}-_O

在线尝试!

使用基于0的索引。

说明:

Σ    }       # sort the input by
 N._         # each number rotated its index to the left
    ï        # then cast to int (otherwise the sort is alphabetic)
      -      # subtract the input from the result
       _O    # then count the 0s

6

Japt -x10 9字节

从0开始

í¶UñÈséYn

试试吧

í¶UñÈséYn     :Implicit input of integer array U
í             :Interleave with
  Uñ          :U sorted by
    È         :Passing each integer at 0-based index Y through the following function
     s        :  Convert to string
      é       :  Rotate right by
       Yn     :    Y negated
 ¶            :Reduce each pair by testing for equality
              :Implicit output of sum of resulting array

4

果冻,9字节

Dṙ"JḌỤ=JS

在线尝试!

Monadic链接,该链接获取一个整数列表并返回一个整数,该整数指示使用1索引执行旋转后保留在适当位置的整数数量。

说明

D         | Convert to decimal digits
 ṙ"J      | Rotate left by index
    Ḍ     | Convert back to integer
     Ụ    | Index in sorted list
      =J  | Check if equal to index in original list
        S | Sum

4

Python 2中104 100 97 93个字节

b=[int((s*-~i)[i:i+len(s)])for i,s in enumerate(input())]
print map(cmp,b,sorted(b)).count(0)

在线尝试!

基于0的索引。

首先旋转每个数字,然后将结果与结果进行比较,但进行排序。


已保存:

  • -3个字节,感谢Outgolfer的Erik
  • -4个字节,这要归功于Kevin Cruijssen(和他的规则更改)


@eriktheoutgolfer谢谢,我太忙于制作lambda,我忘了input():)
TFeld

这就是为什么我首先尝试制作一个完整的程序的原因...:D认真地讲,如果您首先尝试制作一个完整的程序,那么您将清楚地看到是否值得转换为lambda。不要def马上开始(在Python 2中,它们与Python 3相反,几乎没有用)。
,Outgolfer的Erik

我现在允许输入列表作为字符串,因此您可以通过删除周围的重音来删除4个字节s
凯文·克鲁伊森

4

R90 88 85字节

function(x)sum(rank(as.double(substr(strrep(x,L<-sum(x|1)),y<-1:L,y+nchar(x)-1)))==y)

在线尝试!

展开代码并提供说明:

function(x){
    L=sum(x|1)                         # store the length of x

    R=strrep(x,L)                      # repeat each string of vector x L times

    S=substring(R,1:L,1:L+nchar(x)-1)) # for each string of R, extract a substring of the same 
                                       # length of the original number starting from index 1 
                                       # for the 1st element, index 2 for the 2nd and so on
                                       # (this basically rotates the strings )

    Y=as.double(S)                     # convert the strings to numbers

    sum(rank(Y)==1:L)                  # return the number of times the ranks of Y
                                       # match with their original positions
}


2

Stax11个10 字节

ìát'óJ♣á◄·

运行并调试

该程序使用基于0的索引,并将输入作为字符串数组。我利用新输入的clarificatinos节省了一个字节。


2

Perl 5,80 -pa个字节

map$d{$_.substr$_,0,$b%y///c,''}=$b++,@F;$\+=$d{$_}==$r++for sort{$a-$b}keys%d}{

在线尝试!

在STDIN上将输入作为空格分隔的数字;给出从1开始的结果。


2

Pyth,15个字节

sqVSJ.ev.<`bkQJ

在线尝试!使用基于0的索引。

sqVSJ.ev.<`bkQJ   Implicit: Q=eval(input())
     .e      Q    Map elements of Q, as b and with index k, using:
          `b        Convert b to string
        .<  k       Rotate the above left k places
       v            Convert back to integer
    J             Store the above as J
   S              Sort the above
 qV           J   Vectorised equality check with the unsorted list
s                 Sum, implicit output

@FryAmTheEggman我现在允许使用字符串列表作为输入,所以它现在有效。
凯文克鲁伊森

@FryAmTheEggman您可能是对的,我忽略省略时不考虑字典排序与整数排序s-代码的原始版本具有v相同的效果。我将修改它放回

嗯,正如Kevin指出的那样,您现在可以删除反引号,并将输入作为字符串列表保存一个字节。
FryAmTheEggman

2

APL + WIN,23,21 19字节

通过输入整数作为字符的嵌套向量节省了2个字节

+/i=⍋⍎¨(i←⍳⍴v)⌽¨v←⎕

1个索引。

v←⎕ prompt for input. 

(i←⍳⍴v)⌽¨ rotate each set of characters by input indices.

⍋⍎¨ convert characters to integers and get sorted indices.

+/i= sum where original and sorted indices are the same.

在线尝试!由Dyalog Classic提供


不知道是否会保存任何字节,但是我现在允许输入为字符串列表或数字列表列表。
凯文·克鲁伊森

@KevinCruijssen感谢您指出这一点。输入字符串的嵌套向量可节省2个字节
Graham

2

JavaScript(Node.js)107 99 95字节

-8个字节感谢@Shaggy而不是接受字符串数组。由此打了4个字节。这次不会触发内存错误。

a=>[...b=a.map(F=(x,i)=>i--?F(x.slice(1)+x[c=0],i):x)].sort((p,q)=>q-p).map(x=>c+=x==b.pop())|c

在线尝试!

的JavaScript(Node.js的)111个 107字节

-4个字节感谢@Arnauld!

a=>[...b=a.map((x,i)=>"".padEnd(x+i,x+=c='').substr(i,x.length))].sort((p,q)=>q-p).map(x=>c-=x==b.pop())|-c

在线尝试!

JavaScript(Node.js)113111字节

a=>[...b=a.map((x,i)=>"".padEnd(x+i,x).substr(i,`${x}`.length))].sort((p,q)=>p-q).map((x,i)=>x-b[i]||c++,c=0)|c

在线尝试!

0索引。可能会为非常大的条目触发内存错误。


2
99个字节,将输入作为整数字符串数组。
毛茸茸的

@Shaggy谢谢,现在是95个字节;)
Shieru Asakoto

2

Perl 6,50个字节

{sum ^$_ Z==sort {+[~] rotate .[$^i].comb,$i},^$_}

在线尝试!

基于0的索引。还暴露了Rakudo的错误

说明

{                                                }  # Anonymous block
            sort                              ^$_   # Sort indices 0..n
                 {                          },  # by
                              .[$^i]            # element at index i
                                    .comb       # split into chars
                       rotate            ,$i    # rotated i times
                   [~]  # joined
                  +     # converted to number
     ^$_ Z==  # Pairwise equal to original indices 0..n
 sum   # Sum of equal indices

2

PHP159 141 134 130字节

function($a){foreach($a as$x){for($j=$i;$j--;$x=substr($x,1).$x[0]);$b[$x]=$i++;}ksort($b);foreach($b as$z)$y+=++$j==$z;return$y;}

在线尝试!

从零开始的索引。

取消高尔夫:

function( $a ) { 
    // iterate through digits
    foreach( $a as $x ) {
        // rotate the digits the number of times based on their index
        for( $j = $i; $j--; ) {
            // move first digit to last digit
            $x = substr( $x, 1 ) . $x[0];
        }
        // the new number is used as key for sort, value is the original index
        $b[ $x ] = $i++;
    }
    // sort by the new numbers
    ksort( $b );
    // iterate sorted array
    foreach( $b as $z ) {
        // if new index matches original index, increment count ($y)
        if ( ++$j == $z ) {
            $y++;
        }
    }
    return $y;
}
  • -4字节,将输入作为字符串数组,@ xevinCruijssen指出这一点。

我不太了解PHP,但是我现在允许使用字符串列表而不是整数,所以我认为您可以删除.=''?。
凯文·克鲁伊森

@KevinCruijssen你是正确的。采取字符串数组将消除不必要的字符串。我会相应地更新。
640KB


2

T-SQL查询,99字节

Sql没有旋转方法,因此我必须实现自己的语法,因为这是一个查询,所以必须做到不循环。

基于0的索引。

使用表变量作为输入。

SELECT-sum(1/~(z*3))FROM(SELECT~i+rank()over(order by
substring(n+n,i%len(n)+1,len(n))*1)z FROM @)c

在线尝试



1

Perl 5,104个字节

sub f{my$i;grep/\d+$/&&$i++==$&,sort{$a<=>$b}map{my$n=shift;map$n=~s/(.)(.+)/$2$1/,1..$_;"$n.$_"}0..$#_}

在线尝试!

Perl中基于0的索引。取消评论并评论:

sub f {
  my $i;                            #index counter
  grep /\d+$/ && $i++==$&,          #keep/return elems where $i matches original index stored as decimals
  sort { $a<=>$b }                  #sort rotated elems numerically (<=> is the numerical comparison op
  map {                             #loop through input
    my $n = shift;                  #shift(@_) got elem from input array @_
    map $n=~s/(.)(.+)/$2$1/, 1..$_; #rotate left times current index 
    "$n.$_"                         #use rotated number with original index number as decimals (to dont affect sort)
  }
  0..$#_
}

1

红宝石 -ap,77个字节

1个索引。是因为我错过了部分规格,所以之前被临时删除了。

-p读取一行STDIN,并$_在最后输出。-a将读取的行按空格分隔并将其另存为$F

i=0
$_=$F.zip($F.sort_by{|s|s.chars.rotate(i+=1).join.to_i}).count{|a,b|a==b}

在线尝试!


您可以通过替换[...].join.to_ieval [...]*''
门把手

1
@Doorknob不幸的是……在某些极端情况下,如果数字被旋转以使其具有前导零,eval则会将其解释为以8为底的数字,这可能会弄乱我们的计数……
价值墨水

1

Wolfram语言(Mathematica),65个字节

o=Ordering
g=Count[o@MapIndexed[FromDigits@*RotateLeft,#]-o@#,0]&

在线尝试!

基于1。我们将输入作为数字列表的列表,这是有效的,因为Mathematica按长度排序列表,然后按字典顺序排序,即就像原始数字一样。


1

重击204201字节

这里(可能)唯一有趣的事情是使用eval。该算法也很笨拙,因为它创建了一个排序列表,然后读取该列表以确定已更改的索引。

基于1的解决方案。感谢@RobinRyder提供了有用的旋转算法。

for((i=1;i<$#+1;i++));do eval s=\${$i};for((j=0;j<i;j++));do eval s=${s}\${$i};done;eval n=\${s:$i:\${#$i}};echo $n $i;done|sort -nk1,1|{ i=1;c=0;while read d j;do((i==j))&&((c++));((i++));done;echo $c; }

在线尝试!

在Kevin的评论之后修改了代码; 在线尝试!


我对Bash不太了解,但我认为您可以删除之间的最后一个空格;}。另外,您可以将第一个循环更改为for((i=0;++i<=$#;));
凯文·克鲁伊森

@KevinCruijssen-通常我发现Bash和朋友需要该空间来解析命令行。在这种情况下,您是正确的,它可能会被删除。重新基准并预先增加的好主意。202个字节。
PJF

1

200个 160字节

def f(a:Seq[String])=
  a.zipWithIndex
   .map(x=>{val r=x._2%x._1.size;x._1.drop(r)+x._1.take(r)->x._2})
   .sortBy(_._1.toInt)
   .zipWithIndex
   .filter(x=>x._1._2==x._2)
   .size

在线尝试!

0索引。删除缩进和换行符后为160个字符。打印6:

println( f(Seq("8","49","73","102","259","762","2782","3383","9217","37846","89487","7471788")) )
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.