Thử thách:

Đầu vào:

Một danh sách sắp xếp các số nguyên dương.

Đầu ra:

Số lượng số nguyên vẫn ở cùng một chỉ mục, sau khi xoay các chữ số trong mỗi số nguyên, số lần chỉ số của nó về bên trái và sắp xếp lại danh sách đã sửa đổi.

Thí dụ:

Đầu vào: [8,49,73,102,259,762,2782,3383,9217,37846,89487,7471788]
Đầu ra (lập chỉ mục dựa trên 0): 6
Đầu ra (lập chỉ mục dựa trên 1):5

Tại sao?

Lập chỉ mục dựa trên 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

Lập chỉ mục dựa trên 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

Quy tắc thử thách:

• Danh sách đầu vào được đảm bảo chỉ chứa các số nguyên dương.
• Danh sách đầu vào được đảm bảo được sắp xếp từ thấp nhất đến cao nhất.
• Danh sách đầu vào được đảm bảo có ít nhất hai mục.
• Như bạn có thể thấy ở trên, cả lập chỉ mục dựa trên 0 và 1 đều được cho phép. Vui lòng nêu câu trả lời của bạn trong số hai bạn đã sử dụng, vì kết quả đầu ra có thể khác nhau tương ứng!
• Các 0s hàng đầu sau khi quay được bỏ qua, có thể được nhìn thấy với ví dụ dựa trên 1 ở trên, trong đó số nguyên 102trở thành 021sau khi xoay và sau đó được coi là 21.
• Số nguyên được đảm bảo duy nhất trong danh sách đầu vào và được đảm bảo duy nhất sau khi hoàn thành các phép quay.
• Lưu ý rằng chúng ta chỉ nhìn vào vị trí của các số nguyên được xoay tương quan với các vị trí của đầu vào, không phải với các giá trị của danh sách đầu vào. Để làm rõ ý của tôi về điều này: với việc lập danh sách đầu vào [1234,3412]và lập chỉ mục dựa trên 1, danh sách sẽ trở thành [2341,1234]sau khi xoay từng số nguyên, chỉ số của nó là số lần và sau đó khi được sắp xếp trở thành [1234,2341]. Mặc dù cả danh sách đầu vào ban đầu và danh sách xoay đều chứa số nguyên 1234ở vị trí hàng đầu, nhưng chúng không giống nhau! Việc xoay vòng 1234là 3412trước đây. Do đó 0, đầu ra 1 chỉ mục cho danh sách đầu vào này là do hai số nguyên đã hoán đổi vị trí của chúng.
• Đầu vào là linh hoạt. Có thể là danh sách / luồng / mảng số nguyên / chuỗi / mảng chữ số, v.v. Vui lòng cho biết những gì bạn đã sử dụng nếu bạn không lấy đầu vào làm số nguyên.

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Quy tắc chuẩn áp dụng cho câu trả lời của bạn với quy tắc I / O mặc định , vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn (ví dụ TIO ).
• Ngoài ra, thêm một lời giải thích cho câu trả lời của bạn rất được khuyến khích.

Các trường hợp thử nghiệm:

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

Vui lòng tạo thêm các trường hợp thử nghiệm ngẫu nhiên với (hoặc lấy cảm hứng từ) chương trình 05AB1E không được phép này , trong đó đầu vào là kích thước của danh sách ngẫu nhiên (LƯU Ý: đầu ra của trình tạo này có thể không tuân thủ quy tắc " Số nguyên được đảm bảo duy nhất trong danh sách đầu vào và được đảm bảo duy nhất sau khi hoàn thành các phép quay ", vì vậy hãy ghi nhớ điều đó khi sử dụng nó.)

R , 114 107 byte

-5 byte nhờ Giuseppe.

Vượt trội bởi 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)}

Hãy thử trực tuyến!

Chỉ số 0.

Phiên bản bị đánh cắp:

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
}

Để xoay bchữ số của một số nguyên do jvị trí, mã lặp đi lặp lại các chữ số nhiều lần, sau đó có các chữ số ở các vị trí j+1để j+b. Chẳng hạn, để xoay 1024 lần, hãy giữ các giá trị được đánh dấu bằng x(vị trí 5 đến 7):

102102102102
    xxx

nên kết quả là 021.

05AB1E , 9 byte

ΣN._ï}-_O

Hãy thử trực tuyến!

Sử dụng lập chỉ mục dựa trên 0.

Giải trình:

Σ    }       # 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

Japt -x , 10 9 byte

Dựa trên 0

í¶UñÈséYn

Thử nó

í¶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

Thạch , 9 byte

Dṙ"JḌỤ=JS

Hãy thử trực tuyến!

Liên kết đơn thể lấy danh sách các số nguyên và trả về một số nguyên cho biết số nguyên vẫn giữ nguyên sau khi thực hiện phép quay bằng cách sử dụng chỉ mục 1.

Giải trình

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

Python 2 , 104 100 97 93 byte

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

Hãy thử trực tuyến!

Lập chỉ mục dựa trên 0.

Đầu tiên xoay từng số, sau đó so sánh kết quả với kết quả, nhưng được sắp xếp.

Đã lưu:

• -3 byte, nhờ Erik Outgolfer
• -4 byte, nhờ Kevin Cruijssen (và thay đổi quy tắc của anh ấy)

R , 90 88 85 byte

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

Hãy thử trực tuyến!

• Xoay 0 chỉ số
• chiến lược xoay vòng lấy cảm hứng từ câu trả lời của @ RobinRyder
• -5 byte nhờ @Giuseppe

Mã không được kiểm soát với lời giải thích:

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
}

J , 28 26 byte

-2 byte nhờ Jonah

1#.i.@#=[:/:#\".@|.&>":&.>

Hãy thử trực tuyến!

Stax , 11 10 byte

ìát'óJ♣á◄·

Chạy và gỡ lỗi nó

Chương trình này sử dụng lập chỉ mục dựa trên 0 và lấy đầu vào là một chuỗi các chuỗi. Tôi đã lưu một byte bằng cách tận dụng cơ hội của Clarificatinos đầu vào mới.

Perl 5 -pa , 80 byte

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

Hãy thử trực tuyến!

Lấy đầu vào là các số được phân tách bằng dấu cách trên STDIN; cho kết quả dựa trên 1.

Bình thường , 15 byte

sqVSJ.ev.<`bkQJ

Hãy thử trực tuyến! Sử dụng lập chỉ mục dựa trên 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

APL + THẮNG, 23, 21 19 byte

2 byte được lưu bằng cách nhập số nguyên dưới dạng vectơ lồng nhau của các ký tự

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

1 chỉ mục.

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.

Hãy thử trực tuyến! Lịch sự của Dyalog Classic

JavaScript (Node.js) , 107 99 95 byte

-8 byte Cảm ơn @Shaggy đã chấp nhận mảng chuỗi thay thế. Hơn nữa chơi golf 4 byte từ này. Sẽ không kích hoạt lỗi bộ nhớ lần này.

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

Hãy thử trực tuyến!

JavaScript (Node.js) , 111 107 byte

-4 byte Cảm ơn @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

Hãy thử trực tuyến!

JavaScript (Node.js) , 113 111 byte

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

Hãy thử trực tuyến!

Chỉ số 0. Có thể kích hoạt lỗi bộ nhớ cho các mục rất lớn.

Perl 6 , 50 byte

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

Hãy thử trực tuyến!

Lập chỉ mục dựa trên 0. Cũng tiếp xúc với một lỗi Rakudo .

Giải trình

{                                                }  # 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

PHP ,159 141 134 130 byte

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

Hãy thử trực tuyến!

Lập chỉ mục dựa trên không.

Ung dung:

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 byte lấy đầu vào là mảng chuỗi, thx đến @KevinCruijssen để chỉ ra điều đó.

K (Kona) , 25 21byte

-4 byte nhờ ngn!

{+/t=<.:'(t:!#x)!'$x}

Hãy thử trực tuyến!

Truy vấn T-SQL, 99 byte

Sql không có phương thức xoay vòng, vì vậy tôi phải thực hiện cú pháp của riêng mình, vì đây là truy vấn, nó phải được thực hiện mà không cần lặp.

Lập chỉ mục dựa trên 0.

Sử dụng một biến bảng làm đầu vào.

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

Dùng thử trực tuyến

Biểu tượng , 141 byte

procedure f(l)
n:=0
b:=[]
t:=l[k:=1to*l]&m:=k%*t&t:=t[m+1:0]||t[1:m+1]&put(b,[+t,l[k]])&\x
l[i:=1to*l]=sortf(b,1)[i,2]&n+:=1&\x 
return n
end

Hãy thử trực tuyến!

Lập chỉ mục 1

Perl 5 , 104 byte

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

Hãy thử trực tuyến!

Lập chỉ mục dựa trên 0 trong Perl. Ungolfed và bình luận:

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..$#_
}

Hồng ngọc -ap , 77 byte

1 chỉ mục. Đã tạm thời bị xóa trước đó vì tôi đã bỏ lỡ một phần của thông số kỹ thuật.

-pđọc một dòng STDIN và xuất ra $_ở cuối. -aphân chia dòng đọc theo khoảng trắng và lưu nó dưới dạng $F.

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

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 65 byte

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

Hãy thử trực tuyến!

1 dựa. Chúng tôi lấy đầu vào là một danh sách các danh sách chữ số, hoạt động vì các đơn đặt hàng Mathicala liệt kê theo độ dài, sau đó theo từ vựng, tức là giống như các số ban đầu.

Bash , 204 201 byte

Điều thú vị duy nhất ở đây (có thể) là việc sử dụng eval . Thuật toán cũng khó hiểu ở chỗ nó tạo ra một danh sách được sắp xếp sau đó đọc nó để xác định chỉ số / chỉ số thay đổi.

Giải pháp dựa trên 1. Tôi cảm ơn @RobinRyder về thuật toán xoay hữu ích.

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

Hãy thử trực tuyến!

Mã sửa đổi theo ý kiến ​​của Kevin; Hãy thử trực tuyến!

Scala , 200 160 byte

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

Hãy thử trực tuyến!

Chỉ số 0. 160 ký tự sau khi loại bỏ vết lõm và dòng mới. Bản in này 6:

println( f(Seq("8","49","73","102","259","762","2782","3383","9217","37846","89487","7471788")) )