도전:

입력:

양의 정수로 정렬 된 목록입니다.

산출:

각 정수의 자릿수를 왼쪽으로 회전 한 후 수정 된 목록을 다시 정렬 한 후 여전히 정확히 동일한 인덱스에있는 정수의 양입니다.

예:

입력 : [8,49,73,102,259,762,2782,3383,9217,37846,89487,7471788]
출력 (0 기반 인덱스) 6
출력 (1 기반의 인덱스)5

왜?

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

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

도전 규칙 :

• 입력 목록은 양의 정수만 포함하도록 보장됩니다.
• 입력 목록은 최저에서 최고로 정렬됩니다.
• 입력 목록에는 두 개 이상의 항목이 포함되어 있습니다.
• 위에서 볼 수 있듯이 0 기반 및 1 기반 인덱싱이 모두 허용됩니다. 결과에 따라 출력이 다를 수 있으므로 사용한 두 가지 중 어느 것이라도 답하십시오.
• 0회전 후 선행 s는 무시되며, 위의 1 기반 예에서 볼 수 있는데, 여기서 정수 102는 021회전 후 가되고 로 처리됩니다 21.
• 정수는 입력 목록에서 고유하게 보장되며 회전이 완료된 후에도 고유하게 유지됩니다.
• 입력 목록의 값이 아니라 입력 위치와 상관 관계가있는 회전 된 정수의 위치 만 봅니다. 내가 의미하는 바를 명확히하기 위해 : 입력 목록 [1234,3412]및 1 기반 색인을 사용하면 목록은 [2341,1234]각 정수를 회전 한 후 색인 횟수만큼 회전 한 다음 정렬 할 때가됩니다 [1234,2341]. 원래 입력 목록과 회전 목록 1234모두 선행 위치 의 정수 를 포함 하지만 동일하지 않습니다! 회전 된이 1234있었다 3412전에. 따라서이 입력 목록에 대한 1- 색인 출력은입니다 0. 두 정수가 그 위치를 바꿨 기 때문입니다.
• 입력이 유연합니다. 정수 / 문자열 / 숫자 배열 등의 목록 / 스트림 / 배열이 될 수 있습니다. 입력을 정수로 취하지 않은 경우 사용한 것을 적어주십시오.

일반적인 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙 은 기본 I / O 규칙으로 답변에 적용 되므로 STDIN / STDOUT, 적절한 매개 변수 및 반환 유형의 전체 프로그램과 함께 함수 / 방법을 사용할 수 있습니다. 당신의 전화.
• 기본 허점 은 금지되어 있습니다.
• 가능하면 코드 테스트와 링크를 추가하십시오 (예 : TIO ).
• 또한 답변에 대한 설명을 추가하는 것이 좋습니다.

테스트 사례 :

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

입력이 무작위 목록의 크기 인 이 ungolfed 05AB1E 프로그램 을 사용하여 더 많은 무작위 테스트 사례를 생성하거나 영감을 얻으십시오 . 참고 :이 생성기의 출력은 " 정수는 입력 목록을 사용하고 회전이 완료된 후에도 고유 한 상태를 유지할 수 있습니다. "사용시 명심하십시오.)

R , 114 107 바이트

주세페 덕분에 -5 바이트.

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

온라인으로 사용해보십시오!

인덱스가 0입니다.

언 골프 버전 :

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
}

회전하기 b로 정수의 숫자 j위치를 코드는, 숫자 여러 번 반복 위치에 자리 소요 j+1에 j+b. 예를 들어, 1024 번 회전 하려면 값을 x(위치 5-7)으로 표시하십시오.

102102102102
    xxx

결과는 021입니다.

05AB1E , 9 바이트

ΣN._ï}-_O

온라인으로 사용해보십시오!

0 기반 인덱싱을 사용합니다.

설명:

Σ    }       # 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 바이트

0 기반

í¶UñÈséYn

시도 해봐

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

젤리 , 9 바이트

Dṙ"JḌỤ=JS

온라인으로 사용해보십시오!

정수 목록을 가져오고 1- 인덱싱을 사용하여 회전을 수행 한 후 남아있는 정수 수를 나타내는 정수를 반환하는 Monadic 링크.

설명

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

파이썬 (2) , 104 (100) 97 93 바이트

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

온라인으로 사용해보십시오!

0 기반 인덱싱

먼저 각 숫자를 회전 한 다음 결과와 결과를 비교하지만 정렬합니다.

저장 됨 :

• Outgolfer Erik 덕분에 -3 바이트
• Kevin Cruijssen (및 그의 규칙 변경) 덕분에 -4 바이트

R , 90 88 85 바이트

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

온라인으로 사용해보십시오!

• 인덱스가없는 회전
• @RobinRyder의 답변에서 영감을 얻은 로테이션 전략
• @Giuseppe 덕분에 -5 바이트

설명과 함께 풀린 코드 :

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 바이트

Jonah 덕분에 -2 바이트

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

온라인으로 사용해보십시오!

Stax , 11 10 바이트

ìát'óJ♣á◄·

실행 및 디버깅

이 프로그램은 0 기반 인덱싱을 사용하고 문자열 배열로 입력을받습니다. 새로운 입력 clarificatinos를 사용하여 바이트를 절약했습니다.

펄 5 -pa , 80 바이트

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

온라인으로 사용해보십시오!

STDIN에서 공백으로 구분 된 숫자로 입력을받습니다. 1 기반 결과를 제공합니다.

Pyth , 15 바이트

sqVSJ.ev.<`bkQJ

온라인으로 사용해보십시오! 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 바이트

정수를 문자의 중첩 벡터로 입력하여 2 바이트 절약

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

1 색인.

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.

온라인으로 사용해보십시오! Dyalog Classic 제공

JavaScript (Node.js) , 107 99 95 바이트

-8 bytes 대신 문자열 배열을 수락 해 주셔서 감사합니다. 이로부터 4 바이트 더 골프를 쳤다. 이번에는 메모리 오류가 발생하지 않습니다.

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

온라인으로 사용해보십시오!

자바 스크립트 (Node.js를) , 111 (107) 바이트

-4 바이트 감사합니다 @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

온라인으로 사용해보십시오!

자바 스크립트 (Node.js를) , 113 (111) 바이트

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

온라인으로 사용해보십시오!

인덱스가 0입니다. 매우 큰 항목에 대해 메모리 오류가 발생할 수 있습니다.

펄 6 , 50 바이트

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

온라인으로 사용해보십시오!

0 기반 인덱싱 또한 Rakudo 버그가 노출되었습니다 .

설명

{                                                }  # 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 바이트

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

온라인으로 사용해보십시오!

제로 기반 인덱싱

언 골프 드 :

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 바이트는 문자열 배열로 입력을 취하고, 그것을 지적하기 위해 @KevinCruijssen에 thx합니다.

K (코나) , 25 21 바이트

ngn 덕분에 -4 바이트!

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

온라인으로 사용해보십시오!

T-SQL 쿼리, 99 바이트

Sql에는 회전 방법이 없으므로 쿼리이므로 자체 구문을 구현해야했습니다. 루핑하지 않고 수행해야했습니다.

0 기반 인덱싱

테이블 변수를 입력으로 사용

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

온라인으로 사용해보십시오

아이콘 , 141 바이트

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

온라인으로 사용해보십시오!

1 기반 인덱싱

펄 5 , 104 바이트

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

온라인으로 사용해보십시오!

Perl에서 0부터 시작하는 인덱싱 Ungolfed 및 댓글 :

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

루비 -ap , 77 바이트

1- 색인. 사양의 일부를 놓쳐서 이전에 임시 삭제되었습니다.

-pSTDIN의 행을 읽고 $_끝에 출력 합니다. -a읽은 줄을 공백으로 나누고로 저장합니다 $F.

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

온라인으로 사용해보십시오!

Wolfram Language (Mathematica) , 65 바이트

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

온라인으로 사용해보십시오!

1 기반. 우리는 입력을 숫자 목록의 목록으로 취합니다. Mathematica는 길이별로 목록을 주문한 다음 사전 식으로, 즉 원래 숫자와 같이 목록을 정렬하기 때문에 작동합니다.

배쉬 , 204 201 바이트

여기서 유일하게 흥미로운 것은 eval . 이 알고리즘은 정렬 된 목록을 만든 다음 변경된 색인 / 지표를 결정하기 위해 읽습니다.

1 기반 솔루션. 유용한 회전 알고리즘에 대한 @RobinRyder에게 감사드립니다.

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

온라인으로 사용해보십시오!

Kevin의 의견에 따라 코드를 수정했습니다. 온라인으로 사용해보십시오!

스칼라 , 200 160 바이트

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

온라인으로 사용해보십시오!

인덱스가 0입니다. 들여 쓰기 및 줄 바꿈을 제거한 후 160 자. 이것은 6을 인쇄합니다.

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