Tantangan:

Memasukkan:

Daftar bilangan bulat positif yang diurutkan.

Keluaran:

Jumlah bilangan bulat yang masih pada indeks yang sama persis, setelah memutar angka di setiap bilangan bulat jumlah indeksnya ke kiri dan menyortir daftar yang dimodifikasi lagi.

Contoh:

Input: [8,49,73,102,259,762,2782,3383,9217,37846,89487,7471788]
Output (pengindeksan berbasis 0): 6
Output (pengindeksan berbasis 1):5

Mengapa?

Pengindeksan berbasis 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

Pengindeksan berbasis 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

Aturan tantangan:

• Daftar input dijamin hanya mengandung bilangan bulat positif.
• Daftar input dijamin akan diurutkan dari terendah ke tertinggi.
• Daftar input dijamin mengandung setidaknya dua item.
• Seperti yang Anda lihat di atas, pengindeksan berbasis 0 dan 1 diizinkan. Silakan sebutkan jawaban Anda yang mana dari dua yang Anda gunakan, karena output dapat berbeda sesuai!
• Leading 0s setelah rotating diabaikan, yang dapat dilihat dengan contoh berbasis 1 di atas, di mana integer 102menjadi 021setelah rotating, dan kemudian diperlakukan sebagai 21.
• Integer dijamin unik dalam daftar input, dan dijamin tetap unik setelah rotasi selesai.
• Perhatikan bahwa kita hanya melihat posisi bilangan bulat yang diputar terkait dengan posisi input, bukan dengan nilai daftar input. Untuk memperjelas apa yang saya maksudkan dengan ini: dengan daftar masukan [1234,3412]dan pengindeksan berbasis 1, daftar menjadi [2341,1234]setelah memutar setiap bilangan bulat itu jumlah indeks kali, dan kemudian ketika diurutkan menjadi [1234,2341]. Meskipun daftar input asli dan daftar yang diputar berisi bilangan bulat 1234pada posisi terdepan, mereka tidak sama! The diputar 1234adalah 3412sebelumnya. Output 1-diindeks untuk daftar input ini karena itu 0, karena dua bilangan bulat telah bertukar posisi mereka.
• Input fleksibel. Dapat berupa daftar / aliran / array bilangan bulat / string / digit-array, dll. Sebutkan apa yang telah Anda gunakan jika Anda tidak mengambil input sebagai bilangan bulat.

Aturan umum:

• Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang.
  Jangan biarkan bahasa kode-golf mencegah Anda memposting jawaban dengan bahasa yang bukan kode. Cobalah untuk memberikan jawaban sesingkat mungkin untuk bahasa pemrograman 'apa saja'.
• Aturan standar berlaku untuk jawaban Anda dengan aturan I / O default , sehingga Anda diizinkan untuk menggunakan STDIN / STDOUT, fungsi / metode dengan parameter yang tepat dan tipe pengembalian, program penuh. Panggilanmu.
• Celah default tidak diperbolehkan.
• Jika memungkinkan, silakan tambahkan tautan dengan tes untuk kode Anda (yaitu TIO ).
• Juga, menambahkan penjelasan untuk jawaban Anda sangat dianjurkan.

Kasus uji:

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

Jangan ragu untuk membuat lebih banyak kasus uji acak dengan (atau menarik inspirasi dari) program 05AB1E yang tidak disatukan ini , di mana inputnya adalah ukuran daftar acak (CATATAN: output generator ini mungkin tidak mematuhi aturan " Bilangan bulat dijamin unik di input-list, dan dijamin tetap unik setelah rotasi selesai ", jadi ingatlah saat menggunakannya.)

R , 114 107 byte

-5 byte terima kasih kepada Giuseppe.

Dikalahkan oleh 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)}

Cobalah online!

Diindeks 0.

Versi tidak disatukan:

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
}

Untuk memutar bangka integer dengan jposisi, kode mengulangi angka berkali-kali, kemudian mengambil angka di posisi j+1ke j+b. Misalnya, untuk memutar 1024 kali, pertahankan nilai ditandai dengan x(posisi 5 hingga 7):

102102102102
    xxx

jadi hasilnya 021.

05AB1E , 9 byte

ΣN._ï}-_O

Cobalah online!

Menggunakan pengindeksan berbasis 0.

Penjelasan:

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

Berbasis 0

í¶UñÈséYn

Cobalah

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

Jelly , 9 byte

Dṙ"JḌỤ=JS

Cobalah online!

Tautan monadik yang mengambil daftar bilangan bulat dan mengembalikan bilangan bulat yang menunjukkan jumlah bilangan bulat yang tetap berada di tempat setelah melakukan rotasi menggunakan pengindeksan 1.

Penjelasan

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)

Cobalah online!

Pengindeksan berbasis 0.

Pertama-tama memutar setiap angka, dan kemudian membandingkan hasilnya dengan hasil, tetapi diurutkan.

Disimpan:

• -3 byte, terima kasih kepada Erik the Outgolfer
• -4 byte, terima kasih kepada Kevin Cruijssen (dan perubahan aturannya)

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)

Cobalah online!

• Rotasi diindeks 0
• strategi rotasi diilhami oleh jawaban @ RobinRyder
• -5 byte terima kasih kepada @Giuseppe

Kode terbuka dengan penjelasan:

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 terima kasih kepada Jonah

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

Cobalah online!

Stax , 11 10 byte

ìát'óJ♣á◄·

Jalankan dan debug itu

Program ini menggunakan pengindeksan berbasis 0 dan mengambil input sebagai array string. Saya menghemat satu byte dengan mengambil kesempatan dari input yang baru clicicatinos.

Perl 5 -pa , 80 byte

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

Cobalah online!

Mengambil input sebagai nomor yang dipisahkan spasi pada STDIN; memberikan hasil berbasis 1.

Pyth , 15 byte

sqVSJ.ev.<`bkQJ

Cobalah online! Menggunakan pengindeksan berbasis 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 + WIN, 23, 21 19 byte

2 byte disimpan dengan memasukkan bilangan bulat sebagai vektor karakter bersarang

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

1 diindeks.

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.

Cobalah online! Atas perkenan Dyalog Classic

JavaScript (Node.js) , 107 99 95 byte

-8 byte Terima kasih @Shaggy sebagai gantinya menerima berbagai string. Selanjutnya golf 4 byte dari ini. Tidak akan memicu kesalahan memori saat ini.

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

Cobalah online!

JavaScript (Node.js) , 111 107 byte

-4 byte Terima kasih @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

Cobalah online!

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

Cobalah online!

Diindeks 0. Dapat memicu kesalahan memori untuk entri yang sangat besar.

Perl 6 , 50 byte

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

Cobalah online!

Pengindeksan berbasis 0. Juga terkena bug Rakudo .

Penjelasan

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

Cobalah online!

Pengindeksan berbasis nol.

Tidak Disatukan:

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 mengambil input sebagai array string, thx ke @KevinCruijssen untuk menunjukkannya.

K (Kona) , 25 21bytes

-4 byte terima kasih kepada ngn!

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

Cobalah online!

Permintaan T-SQL, 99 byte

Sql tidak memiliki metode rotasi, jadi saya harus menerapkan sintaks saya sendiri, karena ini adalah query, itu harus dilakukan tanpa perulangan.

Pengindeksan berbasis 0.

Menggunakan variabel tabel sebagai input.

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

Cobalah online

Ikon , 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

Cobalah online!

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

Cobalah online!

Pengindeksan berbasis 0 di Perl. Tidak dikumpulkan dan berkomentar:

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

Ruby -ap , 77 byte

1-diindeks. Temp dihapus sebelumnya karena saya melewatkan bagian dari spek.

-pmembaca garis STDIN, dan keluaran $_di akhir. -amemisahkan yang membaca baris demi spasi dan menyimpannya sebagai $F.

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

Cobalah online!

Bahasa Wolfram (Mathematica) , 65 byte

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

Cobalah online!

Berbasis 1. Kami mengambil input sebagai daftar daftar digit, yang berfungsi karena Mathematica memesan daftar dengan panjang, kemudian secara leksikografis, yaitu sama seperti angka asli.

Bash , 204 201 byte

Satu-satunya hal yang menarik di sini (mungkin) adalah penggunaan eval. Algoritma ini juga kikuk karena membuat daftar yang diurutkan kemudian membacanya untuk menentukan indeks / indeks yang diubah.

Solusi berbasis 1. Terima kasih kepada @RobinRyder untuk algoritme rotasi yang bermanfaat.

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

Cobalah online!

Kode yang direvisi mengikuti komentar Kevin; Cobalah online!

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

Cobalah online!

Diindeks 0. 160 karakter setelah menghapus lekukan dan baris baru. Ini mencetak 6:

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