Défi:

Contribution:

Une liste triée d'entiers positifs.

Production:

La quantité d'entiers qui sont toujours au même index exact, après avoir fait tourner les chiffres de chaque entier sa quantité d'index de fois vers la gauche et trié à nouveau la liste modifiée.

Exemple:

Entrée: [8,49,73,102,259,762,2782,3383,9217,37846,89487,7471788]
Sortie (indexation 0): 6
Sortie (indexation 1):5

Pourquoi?

Indexation basée sur 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

Indexation basée sur 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

Règles du défi:

• La liste d'entrées est garantie de ne contenir que des entiers positifs.
• La liste d'entrées est garantie d'être triée du plus bas au plus élevé.
• La liste d'entrée est garantie pour contenir au moins deux éléments.
• Comme vous pouvez le voir ci-dessus, l'indexation basée sur 0 et basée sur 1 est autorisée. Veuillez indiquer dans votre réponse laquelle des deux vous avez utilisée, car les sorties peuvent différer en conséquence!
• Les 0s après rotation sont ignorés, ce qui peut être vu avec l'exemple basé sur 1 ci-dessus, où l'entier 102devient 021après rotation, et est ensuite traité comme 21.
• Les nombres entiers sont garantis uniques dans la liste d'entrée et sont garantis rester uniques une fois les rotations terminées.
• Notez que nous ne regardons que les positions des entiers tournés en corrélation avec les positions de l'entrée, pas avec les valeurs de la liste d'entrée. Pour clarifier ce que je veux dire par ceci: avec la liste d'entrée [1234,3412]et l'indexation basée sur 1, la liste devient [2341,1234]après avoir fait tourner chaque entier son nombre d'indices, puis lorsqu'elle est triée [1234,2341]. Bien que la liste d'entrée d'origine et la liste pivotée contiennent l'entier 1234à la position de tête, elles ne sont pas les mêmes! Le tourné 1234était 3412avant. La sortie indexée 1 pour cette entrée-liste est donc 0, puisque les deux entiers ont échangé leurs positions.
• L'entrée est flexible. Il peut s'agir d'une liste / d'un flux / d'un tableau d'entiers / de chaînes / de tableaux de chiffres, etc. Veuillez indiquer ce que vous avez utilisé si vous ne prenez pas les entrées comme des entiers.

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse avec des règles d'E / S par défaut , vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code (par exemple TIO ).
• De plus, l'ajout d'une explication à votre réponse est fortement recommandé.

Cas de test:

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

N'hésitez pas à générer plus de cas de test aléatoires avec (ou à vous inspirer) de ce programme 05AB1E non golfé , où l'entrée est la taille de la liste aléatoire (REMARQUE: la sortie de ce générateur peut ne pas respecter la règle "Les entiers sont garantis uniques dans la liste d'entrées, et sont garantis pour rester uniques une fois les rotations terminées ", donc gardez cela à l'esprit lorsque vous l'utilisez.)

R , 114 107 octets

-5 octets grâce à Giuseppe.

Dépassé par 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)}

Essayez-le en ligne!

0 indexé.

Version non golfée:

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
}

Pour faire pivoter les bchiffres d'un entier par jpositions, le code répète les chiffres plusieurs fois, puis prend les chiffres en positions j+1à j+b. Par exemple, pour faire pivoter 1024 fois, conservez les valeurs marquées d'un x(positions 5 à 7):

102102102102
    xxx

donc le résultat est 021.

05AB1E , 9 octets

ΣN._ï}-_O

Essayez-le en ligne!

Utilise l'indexation basée sur 0.

Explication:

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

Basé sur 0

í¶UñÈséYn

Essayez-le

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

Gelée , 9 octets

Dṙ"JḌỤ=JS

Essayez-le en ligne!

Lien monadique qui prend une liste d'entiers et renvoie un entier indiquant le nombre d'entiers qui restent en place après avoir effectué la rotation à l'aide de l'indexation 1.

Explication

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 octets

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

Essayez-le en ligne!

Indexation basée sur 0.

Tourne d'abord chaque nombre, puis compare le résultat avec le résultat, mais trié.

Enregistré:

• -3 octets, grâce à Erik l'Outgolfer
• -4 octets, merci à Kevin Cruijssen (et son changement de règle)

R , 90 88 85 octets

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

Essayez-le en ligne!

• Rotation indexée 0
• stratégie de rotation inspirée par la réponse de @ RobinRyder
• -5 octets grâce à @Giuseppe

Code déroulé avec explication:

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 octets

-2 octets grâce à Jonah

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

Essayez-le en ligne!

Stax , 11 10 octets

ìát'óJ♣á◄·

Exécuter et déboguer

Ce programme utilise une indexation basée sur 0 et prend les entrées comme un tableau de chaînes. J'ai économisé un octet en profitant de la nouvelle entrée clarificatinos.

Perl 5 -pa , 80 octets

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

Essayez-le en ligne!

Prend l'entrée sous forme de nombres séparés par des espaces sur STDIN; donne un résultat basé sur 1.

Pyth , 15 octets

sqVSJ.ev.<`bkQJ

Essayez-le en ligne! Utilise l'indexation basée sur 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 octets

2 octets enregistrés en entrant les entiers comme vecteur de caractères imbriqué

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

1 indexé.

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.

Essayez-le en ligne! Gracieuseté de Dyalog Classic

JavaScript (Node.js) , 107 99 95 octets

-8 octets Merci @Shaggy d'avoir accepté un tableau de chaînes à la place. En outre joué 4 octets de cela. Ne déclenchera pas d'erreur de mémoire cette fois.

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

Essayez-le en ligne!

JavaScript (Node.js) , 111 107 octets

-4 octets Merci @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

Essayez-le en ligne!

JavaScript (Node.js) , 113 111 octets

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

Essayez-le en ligne!

0 indexé. Peut déclencher une erreur de mémoire pour les entrées très volumineuses.

Perl 6 , 50 octets

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

Essayez-le en ligne!

Indexation basée sur 0. Également exposé un bug Rakudo .

Explication

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

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

Essayez-le en ligne!

Indexation à base zéro.

Non golfé:

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 octets prenant l'entrée comme tableau de chaînes, merci à @KevinCruijssen pour l'avoir signalé.

K (Kona) , 25 21 octets

-4 octets grâce à ngn!

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

Essayez-le en ligne!

Requête T-SQL, 99 octets

Sql n'a pas de méthode de rotation, j'ai donc dû implémenter ma propre syntaxe, car il s'agit d'une requête, elle devait être effectuée sans boucle.

Indexation basée sur 0.

Utilisation d'une variable de table en entrée.

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

Essayez-le en ligne

Icône , 141 octets

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

Essayez-le en ligne!

Indexation basée sur 1

Perl 5 , 104 octets

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

Essayez-le en ligne!

Indexation basée sur 0 en Perl. Non golfé et commenté:

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

Rubis -ap , 77 octets

1 indexé. Temp a été supprimé plus tôt, car j'ai raté une partie de la spécification.

-plit une ligne de STDIN et sort $_à la fin. -adivise cette ligne par des espaces et l'enregistre sous $F.

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

Essayez-le en ligne!

Wolfram Language (Mathematica) , 65 octets

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

Essayez-le en ligne!

1 basé. Nous prenons l'entrée comme une liste de listes de chiffres, ce qui fonctionne parce que Mathematica ordonne les listes par longueur, puis lexicographiquement, c'est-à-dire tout comme les nombres originaux.

Bash , 204 201 octets

La seule chose intéressante ici (peut-être) est l'utilisation de eval . L'algorithme est également maladroit en ce qu'il crée une liste triée puis la lit afin de déterminer le ou les index modifiés.

Solution basée sur 1. Mes remerciements à @RobinRyder pour l'algorithme de rotation utile.

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

Essayez-le en ligne!

Code révisé suite aux commentaires de Kevin; Essayez-le en ligne!

Scala , 200 160 octets

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

Essayez-le en ligne!

0 indexé. 160 caractères après suppression de l'indentation et des sauts de ligne. Cela imprime 6:

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