Wyzwanie:

Wkład:

Posortowana lista dodatnich liczb całkowitych.

Wynik:

Liczba liczb całkowitych, które wciąż mają dokładnie ten sam indeks, po obróceniu cyfr w każdej liczbie całkowitej jej indeks razy w lewo i ponownym posortowaniu zmodyfikowanej listy.

Przykład:

Dane wejściowe: Dane [8,49,73,102,259,762,2782,3383,9217,37846,89487,7471788]
wyjściowe (indeksowanie 0): Dane 6
wyjściowe (indeksowanie 1):5

Dlaczego?

Indeksowanie na podstawie 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

Indeksowanie na podstawie 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

Zasady konkursu:

• Lista wejściowa z pewnością zawiera wyłącznie dodatnie liczby całkowite.
• Lista wejściowa gwarantuje posortowanie od najniższej do najwyższej.
• Lista wejściowa z pewnością zawiera co najmniej dwa elementy.
• Jak widać powyżej, zarówno indeksowanie oparte na 0, jak i oparte na 1 jest dozwolone. Podaj w swojej odpowiedzi, którego z dwóch użyłeś, ponieważ wyniki mogą się odpowiednio różnić!
• Wiodące 0s po obracaniu są ignorowane, co można zobaczyć na powyższym przykładzie opartym na 1, gdzie liczba całkowita 102staje się 021po obracaniu, a następnie jest traktowana jako 21.
• Liczby całkowite są gwarantowane jako unikalne na liście wejść i gwarantują, że pozostaną unikalne po zakończeniu rotacji.
• Zauważ, że patrzymy tylko na pozycje obróconych liczb całkowitych w korelacji z pozycjami wejścia, a nie z wartościami listy wejść. Aby wyjaśnić, co mam na myśli przez to: dzięki liście danych wejściowych [1234,3412]i indeksowaniu opartemu na 1, lista staje się [2341,1234]po obróceniu każdej liczby całkowitej liczbę indeksów razy, a następnie po sortowaniu [1234,2341]. Chociaż zarówno oryginalna lista wejściowa, jak i lista obrócona zawiera liczbę całkowitą 1234w pozycji wiodącej, nie są one takie same! Obrócony 1234był 3412wcześniej. Dlatego indeksowane wyjście 1 dla tej listy wejściowej jest 0, ponieważ dwie liczby całkowite zamieniły swoje pozycje.
• Dane wejściowe są elastyczne. Może być listą / strumieniem / tablicą liczb całkowitych / ciągów znaków / tablic cyfrowych itp. Podaj, czego użyłeś, jeśli nie przyjmujesz danych wejściowych jako liczb całkowitych.

Główne zasady:

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.
  Nie pozwól, aby języki gry w golfa zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
• Do odpowiedzi mają zastosowanie standardowe reguły z domyślnymi regułami We / Wy , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami i typem zwracanych, pełnych programów. Twoja decyzja.
• Domyślne luki są zabronione.
• Jeśli to możliwe, dodaj link z testem kodu (tj. TIO ).
• Zalecane jest również dodanie wyjaśnienia do odpowiedzi.

Przypadki testowe:

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

Generuj więcej losowych przypadków testowych za pomocą (lub czerpiąc inspirację) z tego nieoznakowanego programu 05AB1E , w którym dane wejściowe są wielkości losowej listy (UWAGA: dane wyjściowe tego generatora mogą być niezgodne z regułą: „ Liczby całkowite są gwarantowane unikalne w listę wejściową i gwarantuje się, że pozostaną unikalne po zakończeniu rotacji ”, więc należy o tym pamiętać podczas korzystania z niej).

R , 114 107 bajtów

-5 bajtów dzięki Giuseppe.

Outgolfed by 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)}

Wypróbuj online!

0-indeksowane.

Wersja bez golfa:

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
}

Aby obrócić bcyfry liczby całkowitej według jpozycji, kod powtarza cyfry wiele razy, a następnie przenosi cyfry w pozycjach j+1do j+b. Na przykład, aby obrócić 1024 razy, pozostaw wartości oznaczone x(pozycje od 5 do 7):

102102102102
    xxx

więc wynik jest 021.

05AB1E , 9 bajtów

ΣN._ï}-_O

Wypróbuj online!

Korzysta z indeksowania opartego na 0.

Wyjaśnienie:

Σ    }       # 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 bajtów

W oparciu o 0

í¶UñÈséYn

Spróbuj

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

Galaretka , 9 bajtów

Dṙ"JḌỤ=JS

Wypróbuj online!

Łącze monadyczne, które pobiera listę liczb całkowitych i zwraca liczbę całkowitą wskazującą liczbę liczb całkowitych, które pozostają na miejscu po wykonaniu obrotu za pomocą indeksowania 1.

Wyjaśnienie

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 bajtów

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

Wypróbuj online!

Indeksowanie na podstawie 0.

Najpierw obraca każdą liczbę, a następnie porównuje wynik z wynikiem, ale sortuje.

Zapisano:

• -3 bajty, dzięki Erikowi Outgolfer
• -4 bajty, dzięki Kevin Cruijssen (i jego zmianie zasad)

R , 90 88 85 bajtów

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

Wypróbuj online!

• Obrót indeksowany 0
• strategia rotacji inspirowana odpowiedzią @ RobinRyder
• -5 bajtów dzięki @Giuseppe

Kod rozwinięty z wyjaśnieniem:

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 bajtów

-2 bajty dzięki Jonaszowi

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

Wypróbuj online!

Stax , 11 10 bajtów

ìát'óJ♣á◄·

Uruchom i debuguj

Ten program używa indeksowania opartego na 0 i przyjmuje dane wejściowe jako tablicę ciągów. Zaoszczędziłem bajt, korzystając z nowych danych wejściowych clarificatinos.

Perl 5 -pa , 80 bajtów

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

Wypróbuj online!

Pobiera dane wejściowe jako liczby oddzielone spacjami na STDIN; daje wynik oparty na 1.

Pyth , 15 bajtów

sqVSJ.ev.<`bkQJ

Wypróbuj online! Wykorzystuje indeksowanie 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 bajtów

2 bajty zapisane przez wprowadzenie liczb całkowitych jako zagnieżdżonego wektora znaków

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

1 indeksowany.

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.

Wypróbuj online! Dzięki uprzejmości Dyalog Classic

JavaScript (Node.js) , 107 99 95 bajtów

-8 bajtów Dzięki @Shaggy za akceptację tablicy ciągów zamiast. Dalsze 4 bajty z tego golfa. Tym razem nie spowoduje błędu pamięci.

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

Wypróbuj online!

JavaScript (Node.js) , 111 107 bajtów

-4 bajty Dzięki @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

Wypróbuj online!

JavaScript (Node.js) , 113 111 bajtów

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

Wypróbuj online!

0-indeksowane. Może powodować błąd pamięci dla bardzo dużych wpisów.

Perl 6 , 50 bajtów

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

Wypróbuj online!

Indeksowanie na podstawie 0. Wystawiony również błąd Rakudo .

Wyjaśnienie

{                                                }  # 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 bajtów

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

Wypróbuj online!

Indeksowanie zerowe.

Nie golfowany:

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 bajty przyjmujące dane wejściowe jako tablicę ciągów, dziękuję @KevinCruijssen za wskazanie tego.

K (Kona) , 25 21 bajtów

-4 bajty dzięki ngn!

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

Wypróbuj online!

Zapytanie T-SQL, 99 bajtów

Sql nie ma metody rotacji, więc musiałem zaimplementować własną składnię, ponieważ jest to zapytanie, musiało zostać wykonane bez zapętlania.

Indeksowanie na podstawie 0.

Wykorzystanie zmiennej tabeli jako danych wejściowych.

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

Wypróbuj online

Ikona , 141 bajtów

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

Wypróbuj online!

Indeksowanie 1

Perl 5 , 104 bajtów

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

Wypróbuj online!

Indeksowanie oparte na 0 w Perlu. Nie golfił i skomentował:

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

Rubinowy -ap , 77 bajtów

1-indeksowany. Został wcześniej usunięty temp, ponieważ brakowało części specyfikacji.

-podczytuje linię STDIN i wyświetla $_na końcu. -adzieli czytaną linię spacjami i zapisuje ją jako $F.

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

Wypróbuj online!

Wolfram Language (Mathematica) , 65 bajtów

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

Wypróbuj online!

Na podstawie 1. Traktujemy dane wejściowe jako listę list cyfr, co działa, ponieważ Mathematica porządkuje listy według długości, a następnie leksykograficznie, tj. Tak jak oryginalne liczby.

Bash , 204 201 bajtów

Jedyną interesującą rzeczą (prawdopodobnie) jest użycie eval. Algorytm jest również niezręczny, ponieważ tworzy posortowaną listę, a następnie odczytuje ją w celu ustalenia zmienionego indeksu / indeksów.

Rozwiązanie oparte na 1. Moje podziękowania dla @RobinRyder za pomocny algorytm rotacji.

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

Wypróbuj online!

Zmieniony kod po komentarzach Kevina; Wypróbuj online!

Scala , 200 160 bajtów

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

Wypróbuj online!

0-indeksowane. 160 znaków po usunięciu wcięcia i znaku nowej linii. Wyświetla 6:

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