Desafío:

Entrada:

Una lista ordenada de enteros positivos.

Salida:

La cantidad de enteros que todavía están exactamente en el mismo índice, después de rotar los dígitos en cada número entero su cantidad de índice hacia la izquierda y ordenar la lista modificada nuevamente.

Ejemplo:

Entrada: [8,49,73,102,259,762,2782,3383,9217,37846,89487,7471788]
Salida (indexación basada en 0): 6
Salida (indexación basada en 1):5

¿Por qué?

Indexación basada en 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

Indexación basada en 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

Reglas de desafío:

• Se garantiza que la lista de entrada solo contiene enteros positivos.
• Se garantiza que la lista de entrada se ordenará de menor a mayor.
• Se garantiza que la lista de entrada contiene al menos dos elementos.
• Como puede ver arriba, se permite la indexación basada en 0 y en 1. Indique en su respuesta cuál de los dos ha utilizado, ya que los resultados pueden diferir en consecuencia.
• Los 0s iniciales después de rotar se ignoran, lo que se puede ver con el ejemplo basado en 1 anterior, donde el entero se 102convierte 021después de rotar, y luego se trata como 21.
• Los enteros se garantizan únicos en la lista de entrada, y se garantiza que seguirán siendo únicos después de que se completen las rotaciones.
• Tenga en cuenta que solo miramos las posiciones de los enteros rotados en correlación con las posiciones de la entrada, no con los valores de la lista de entrada. Para aclarar lo que quiero decir con esto: con la lista de entrada [1234,3412]y la indexación basada en 1, la lista se convierte [2341,1234]después de rotar cada número entero en su cantidad de índice de veces, y luego cuando se ordena [1234,2341]. Aunque tanto la lista de entrada original como la lista rotada contienen el número entero 1234en la posición inicial , ¡no son lo mismo! El rotado 1234era 3412antes. La salida indexada en 1 para esta lista de entrada es 0, por lo tanto , ya que los dos enteros han intercambiado sus posiciones.
• La entrada es flexible. Puede ser una lista / secuencia / matriz de enteros / cadenas / matrices de dígitos, etc. Indique lo que ha utilizado si no toma las entradas como enteros.

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de code-golf lo desanimen a publicar respuestas con lenguajes que no sean codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Las reglas estándar se aplican a su respuesta con las reglas de E / S predeterminadas , por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código (es decir, TIO ).
• Además, se recomienda agregar una explicación para su respuesta.

Casos de prueba:

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

Siéntase libre de generar más casos de prueba aleatorios con (o inspirarse en) este programa 05AB1E sin golf , donde la entrada es del tamaño de la lista aleatoria (NOTA: la salida de este generador podría no cumplir con la regla "Los enteros están garantizados únicos en la lista de entrada, y se garantiza que seguirán siendo únicos después de que se completen las rotaciones ", así que tenlo en cuenta al usarlo).

R , 114 bytes

-5 bytes gracias a Giuseppe.

Superado por 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)}

Pruébalo en línea!

0 indexado.

Versión sin golf:

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
}

Para girar los bdígitos de un número entero de jposiciones, el código se repite los dígitos muchas veces, toma entonces los dígitos en las posiciones j+1a j+b. Por ejemplo, para rotar 1024 veces, mantenga los valores marcados con un x(posiciones 5 a 7):

102102102102
    xxx

entonces el resultado es 021.

05AB1E , 9 bytes

ΣN._ï}-_O

Pruébalo en línea!

Utiliza indexación basada en 0.

Explicación:

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

Basado en 0

í¶UñÈséYn

Intentalo

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

Jalea , 9 bytes

Dṙ"JḌỤ=JS

Pruébalo en línea!

Enlace monádico que toma una lista de enteros y devuelve un número entero que indica el número de enteros que permanecen en su lugar después de realizar la rotación usando la indexación 1.

Explicación

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 bytes

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

Pruébalo en línea!

Indexación basada en 0.

Primero gira cada número, y luego compara el resultado con el resultado, pero ordenado.

Salvado:

• -3 bytes, gracias a Erik the Outgolfer
• -4 bytes, gracias a Kevin Cruijssen (y su cambio de regla)

R , 90 88 85 bytes

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

Pruébalo en línea!

• Rotación indexada 0
• estrategia de rotación inspirada en la respuesta de @ RobinRyder
• -5 bytes gracias a @Giuseppe

Código desenrollado con explicación:

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 bytes

-2 bytes gracias a Jonás

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

Pruébalo en línea!

Stax , 11 10 bytes

ìát'óJ♣á◄·

Ejecutar y depurarlo

Este programa utiliza indexación basada en 0 y toma la entrada como una matriz de cadenas. Ahorré un byte aprovechando la nueva entrada clarificatinos.

Perl 5 -pa , 80 bytes

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

Pruébalo en línea!

Toma datos como números separados por espacios en STDIN; da un resultado basado en 1.

Pyth , 15 bytes

sqVSJ.ev.<`bkQJ

Pruébalo en línea! Utiliza indexación basada en 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 bytes

2 bytes guardados al ingresar los enteros como un vector anidado de caracteres

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

1 indexado.

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.

Pruébalo en línea! Cortesía de Dyalog Classic.

JavaScript (Node.js) , 107 99 95 bytes

-8 bytes Gracias @Shaggy por aceptar una matriz de cadenas en su lugar. Más golfed 4 bytes de esto. Esta vez no activará un error de memoria.

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

Pruébalo en línea!

JavaScript (Node.js) , 111 107 bytes

-4 bytes Gracias @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

Pruébalo en línea!

JavaScript (Node.js) , 113 111 bytes

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

Pruébalo en línea!

0 indexado. Puede provocar un error de memoria para entradas muy grandes.

Perl 6 , 50 bytes

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

Pruébalo en línea!

Indexación basada en 0. También expuso un error Rakudo .

Explicación

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

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

Pruébalo en línea!

Indexación basada en cero.

Sin 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 bytes que toman la entrada como una matriz de cadenas, gracias a @KevinCruijssen para señalar eso.

K (Kona) , 25 21bytes

-4 bytes gracias a ngn!

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

Pruébalo en línea!

Consulta T-SQL, 99 bytes

SQL no tiene un método rotativo, por lo que tuve que implementar mi propia sintaxis, ya que esta es una consulta, tenía que hacerse sin bucle.

Indexación basada en 0.

Usando una variable de tabla como entrada.

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

Pruébalo en línea

Icono , 141 bytes

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

Pruébalo en línea!

Indexación basada en 1

Perl 5 , 104 bytes

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

Pruébalo en línea!

Indización basada en 0 en Perl. Ungolfed y comentó:

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 bytes

1 indexado. La temperatura se eliminó anteriormente porque me perdí parte de la especificación.

-plee una línea de STDIN y sale $_al final. -adivide esa línea de lectura por espacios y la guarda como $F.

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

Pruébalo en línea!

Wolfram Language (Mathematica) , 65 bytes

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

Pruébalo en línea!

Basado en 1. Tomamos la entrada como una lista de listas de dígitos, que funciona porque Mathematica ordena las listas por longitud, luego lexicográficamente, es decir, al igual que los números originales.

Bash , 204 201 bytes

Lo único interesante aquí (posiblemente) es el uso de eval . El algoritmo también es torpe porque crea una lista ordenada y luego la lee para determinar los índices / índices modificados.

Solución a base de 1. Mi agradecimiento a @RobinRyder por el útil algoritmo de rotación.

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

Pruébalo en línea!

Código revisado después de los comentarios de Kevin; Pruébalo en línea!

Scala , 200 160 bytes

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

Pruébalo en línea!

0 indexado. 160 caracteres después de eliminar la sangría y las nuevas líneas. Esto imprime 6:

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