Herausforderung:

Eingang:

Eine sortierte Liste positiver Ganzzahlen.

Ausgabe:

Die Anzahl der Ganzzahlen, die sich noch auf dem exakt gleichen Index befinden, nachdem die Ziffern in jeder Ganzzahl mehrmals nach links gedreht und die geänderte Liste erneut sortiert wurden.

Beispiel:

Eingabe: [8,49,73,102,259,762,2782,3383,9217,37846,89487,7471788]
Ausgabe (0-basierte Indizierung): 6
Ausgabe (1-basierte Indizierung):5

Warum?

0-basierte Indizierung:

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

1-basierte Indizierung:

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

Herausforderungsregeln:

• Die Eingabeliste enthält garantiert nur positive ganze Zahlen.
• Die Eingabeliste wird garantiert von der niedrigsten zur höchsten sortiert.
• Die Eingabeliste enthält garantiert mindestens zwei Einträge.
• Wie Sie oben sehen können, ist sowohl eine 0-basierte als auch eine 1-basierte Indizierung zulässig. Bitte geben Sie in Ihrer Antwort an, welche von beiden Sie verwendet haben, da die Ausgaben entsprechend unterschiedlich sein können!
• Führende 0s nach ignoriert Drehen, die mit dem 1-basierten Beispiel gesehen werden können oben, wobei die ganze Zahl 102wird 021nach dem Drehen, und wird dann behandelt , als 21.
• Ganzzahlen sind in der Eingabeliste garantiert eindeutig und bleiben auch nach Abschluss der Umdrehungen eindeutig.
• Beachten Sie, dass wir nur die Positionen der gedrehten ganzen Zahlen in Korrelation mit den Positionen der Eingabe betrachten, nicht mit den Werten der Eingabeliste. Um zu verdeutlichen, was ich damit meine: Mit der Eingabeliste [1234,3412]und der 1-basierten Indizierung wird die Liste [2341,1234]nach dem Drehen jeder ganzen Zahl so oft indexiert, bis sie sortiert wird [1234,2341]. Obwohl sowohl die ursprüngliche Eingabeliste als auch die gedrehte Liste die Ganzzahl 1234an der führenden Position enthalten, sind sie nicht gleich! Der 1234wurde 3412vorher gedreht . Die 1-indizierte Ausgabe für diese Eingabeliste lautet daher 0, da die beiden Ganzzahlen ihre Positionen vertauscht haben.
• Die Eingabe ist flexibel. Kann eine Liste / ein Stream / ein Array von Ganzzahlen / Zeichenfolgen / Ziffern-Arrays usw. sein. Bitte geben Sie an, was Sie verwendet haben, wenn Sie die Eingaben nicht als Ganzzahlen verwenden.

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln mit Standard-E / A-Regeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp, verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu (z. B. TIO ).
• Außerdem wird dringend empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

Testfälle:

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

Sie können mit diesem ungolfed 05AB1E-Programm weitere zufällige Testfälle generieren (oder sich von diesen inspirieren lassen) , wobei die Eingabe der Größe der Zufallsliste entspricht (HINWEIS: Die Ausgabe dieses Generators entspricht möglicherweise nicht der Regel " Ganzzahlen sind garantiert eindeutig in" die Eingabeliste und bleiben nach Abschluss der Rotationen garantiert eindeutig ", denken Sie also daran, wenn Sie sie verwenden.)

R , 114 107 Bytes

-5 Bytes dank Giuseppe.

Von digEmAll überfordert.

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

Probieren Sie es online!

0-indiziert.

Ungolfed-Version:

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
}

Um die bZiffern einer Ganzzahl um jPositionen zu drehen , wiederholt der Code die Ziffern viele Male und nimmt dann die Ziffern in Positionen j+1bis auf j+b. Wenn Sie beispielsweise 102viermal drehen möchten, lassen Sie die Werte mit einem x(Positionen 5 bis 7) markiert :

102102102102
    xxx

Das Ergebnis ist also 021.

05AB1E , 9 Bytes

ΣN._ï}-_O

Probieren Sie es online!

Verwendet eine 0-basierte Indizierung.

Erläuterung:

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

0-basiert

í¶UñÈséYn

Versuch es

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

Gelee , 9 Bytes

Dṙ"JḌỤ=JS

Probieren Sie es online!

Monadischer Link, der eine Liste von Ganzzahlen aufnimmt und eine Ganzzahl zurückgibt, die die Anzahl der Ganzzahlen angibt, die nach dem Ausführen der Rotation mit 1-Indexierung bestehen bleiben.

Erläuterung

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)

Probieren Sie es online!

0-basierte Indizierung.

Dreht zuerst jede Zahl und vergleicht dann das Ergebnis mit dem Ergebnis, aber sortiert.

Gerettet:

• -3 Bytes, danke an Erik den Outgolfer
• -4 Bytes, dank Kevin Cruijssen (und seiner Regeländerung)

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)

Probieren Sie es online!

• 0-indizierte Drehung
• Rotationsstrategie, inspiriert von der Antwort von @ RobinRyder
• -5 Bytes dank @ Giuseppe

Abgerollter Code mit Erklärung:

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 danke an Jonah

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

Probieren Sie es online!

Stax , 11 10 Bytes

ìát'óJ♣á◄·

Führen Sie es aus und debuggen Sie es

Dieses Programm verwendet eine 0-basierte Indizierung und nimmt Eingaben als ein Array von Zeichenfolgen entgegen. Ich habe ein Byte gespart, indem ich die Gelegenheit der neuen Input Clarificatinos genutzt habe.

Perl 5 -pa , 80 Bytes

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

Probieren Sie es online!

Übernimmt die Eingabe als durch Leerzeichen getrennte Zahlen in STDIN. gibt 1-basiertes Ergebnis.

Pyth , 15 Bytes

sqVSJ.ev.<`bkQJ

Probieren Sie es online! Verwendet eine 0-basierte Indizierung.

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 werden durch Eingabe der ganzen Zahlen als verschachtelter Vektor von Zeichen gespeichert

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

1 indiziert.

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.

Probieren Sie es online! Mit freundlicher Genehmigung von Dyalog Classic

JavaScript (Node.js) , 107 99 95 Byte

-8 Bytes Vielen Dank an @Shaggy, dass er stattdessen eine Reihe von Zeichenfolgen akzeptiert. Weitere 4 Bytes davon golfen. Löst dieses Mal keinen Speicherfehler aus.

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

Probieren Sie es online!

JavaScript (Node.js) , 111 107 Bytes

-4 Bytes Danke @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

Probieren Sie es online!

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

Probieren Sie es online!

0-indiziert. Kann bei sehr großen Einträgen einen Speicherfehler auslösen.

Perl 6 , 50 Bytes

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

Probieren Sie es online!

0-basierte Indizierung. Außerdem wurde ein Rakudo-Bug entdeckt .

Erläuterung

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

Probieren Sie es online!

Nullbasierte Indizierung.

Ungolfed:

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 Eingabe als Array von Strings, danke an @KevinCruijssen für den Hinweis.

K (Kona) , 25 21 Bytes

-4 Bytes dank ngn!

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

Probieren Sie es online!

T-SQL-Abfrage, 99 Byte

Sql hat keine rotierende Methode, daher musste ich meine eigene Syntax implementieren, da dies eine Abfrage ist, die ohne Schleifen ausgeführt werden musste.

0-basierte Indizierung.

Verwendung einer Tabellenvariablen als Eingabe.

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

Probieren Sie es online aus

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

Probieren Sie es online!

1-basierte Indizierung

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

Probieren Sie es online!

0-basierte Indizierung in Perl. Ungolfed und kommentiert:

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

Rubin -ap , 77 Bytes

1-indiziert. Wurde temporär gelöscht, weil ich einen Teil der Spezifikation verpasst habe.

-pLiest eine STDIN-Zeile und gibt sie $_am Ende aus. -ateilt die gelesene Zeile durch Leerzeichen und speichert sie als $F.

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

Probieren Sie es online!

Wolfram Language (Mathematica) , 65 Byte

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

Probieren Sie es online!

1-basiert. Wir nehmen die Eingabe als Liste von Ziffernlisten, was funktioniert, weil Mathematica die Listen nach Länge sortiert und dann lexikographisch, dh genau wie die ursprünglichen Zahlen.

Bash , 204 201 Bytes

Das einzig Interessante hier ist (möglicherweise) die Verwendung von eval. Der Algorithmus ist auch insofern klobig, als er eine sortierte Liste erstellt und diese dann liest, um geänderte Indizes zu bestimmen.

1-basierte Lösung. Mein Dank geht an @RobinRyder für den hilfreichen Rotationsalgorithmus.

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

Probieren Sie es online!

Überarbeiteter Code nach Kevins Kommentaren; Probieren Sie es 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

Probieren Sie es online!

0-indiziert. 160 Zeichen nach Entfernen von Einrückungen und Zeilenumbrüchen. Dies druckt 6:

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