Posizione ruotata di numeri interi


20

Sfida:

Ingresso:

Un elenco ordinato di numeri interi positivi.

Produzione:

La quantità di numeri interi che si trovano sempre nello stesso indice esatto, dopo aver ruotato le cifre in ciascun numero intero il suo indice di volte verso sinistra e aver nuovamente ordinato l'elenco modificato.

Esempio:

Input: [8,49,73,102,259,762,2782,3383,9217,37846,89487,7471788]
Output (indicizzazione basata su 0): 6
Output (indicizzazione basata su 1):5

Perché?

Indicizzazione basata su 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

Indicizzazione basata su 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

Regole della sfida:

  • Si garantisce che l'elenco di input contenga solo numeri interi positivi.
  • L'elenco di input è garantito per essere ordinato dal più basso al più alto.
  • L'elenco di input è garantito per contenere almeno due elementi.
  • Come puoi vedere sopra, è consentita l'indicizzazione sia in base 0 che in base 1. Indica nella tua risposta quale delle due hai usato, poiché le uscite possono differire di conseguenza!
  • Le 0s iniziali dopo la rotazione vengono ignorate, come si può vedere nell'esempio in base 1 sopra, in cui l'intero 102diventa 021dopo la rotazione e viene quindi trattato come 21.
  • I numeri interi sono garantiti univoci nell'elenco di input e sono garantiti per rimanere unici dopo il completamento delle rotazioni.
  • Si noti che osserviamo solo le posizioni degli interi ruotati in correlazione con le posizioni dell'input, non con i valori dell'elenco input. Per chiarire cosa intendo con questo: con la lista di input [1234,3412]e l'indicizzazione basata su 1, la lista diventa [2341,1234]dopo aver ruotato ogni numero intero la sua quantità di indice di volte, e poi quando diventa ordinata diventa [1234,2341]. Sebbene sia l'elenco di input originale sia l'elenco ruotato contengano il numero intero 1234nella posizione principale, non sono gli stessi! Il ruotato 1234era 3412prima. L'output 1 indicizzato per questo elenco di input è quindi 0, poiché i due numeri interi hanno scambiato le loro posizioni.
  • L'input è flessibile. Può essere un elenco / flusso / matrice di numeri interi / stringhe / array di cifre, ecc. Indica cosa hai usato se non prendi gli input come numeri interi.

Regole generali:

  • Questo è , quindi vince la risposta più breve in byte.
    Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
  • Per la tua risposta valgono regole standard con regole I / O predefinite , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
  • Sono vietate le scappatoie predefinite .
  • Se possibile, aggiungi un link con un test per il tuo codice (ad es. TIO ).
  • Inoltre, si consiglia vivamente di aggiungere una spiegazione per la risposta.

Casi 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

Sentiti libero di generare più casi di test casuali con (o trarre ispirazione da) questo programma 05AB1E non golfato , in cui l'input ha le dimensioni dell'elenco casuale (NOTA: l'output di questo generatore potrebbe non essere conforme alla regola "I numeri interi sono garantiti univoci in l'elenco di input e sono garantiti per rimanere unici dopo che le rotazioni sono state completate ", quindi tienilo a mente quando lo usi.)


Possiamo supporre che l'input abbia almeno 2 elementi?
Robin Ryder,

2
@RobinRyder Hmm, il mio primo pensiero sarebbe no, ma dal momento che non ho casi di test con singoli articoli e non aggiungerà molto alla sfida, perché no. Aggiungerò una regola che garantisce che l'elenco di input contenga almeno 2 elementi.
Kevin Cruijssen,

Possiamo accettare input come un elenco di stringhe?
Incarnazione dell'ignoranza

1
@Shaggy Ho informato le risposte che pensavo ne avrebbero beneficiato. Se vedi anche quelli che potrebbero trarne beneficio, sentiti libero di avvisare anche loro.
Kevin Cruijssen,

1
Dall'esempio sembra che l'output dovrebbe essere "La quantità di numeri interi che sono ancora nello stesso indice esatto, dopo aver ruotato le cifre in ciascun numero intero la sua quantità di indice di volte verso sinistra e aver riordinato l'array "?
qwr

Risposte:


11

R , 114 107 byte

-5 byte grazie a Giuseppe.

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

Provalo online!

0-indicizzati.

Versione non golfata:

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
}

Per ruotare le bcifre di un numero intero da jposizioni, il codice ripete le cifre molte volte, poi prende le cifre nelle posizioni j+1a j+b. Ad esempio, per ruotare 1024 volte, mantenere i valori contrassegnati con un x(posizioni da 5 a 7):

102102102102
    xxx

quindi il risultato è 021.



@Giuseppe Grazie! Ho bisogno di ricordare seq(a=...). Mi aspetto che ci sia un po 'di Mapmagia da eseguire, ma i miei tentativi hanno lasciato invariato il conteggio dei byte.
Robin Ryder,

Mappotrebbe essere un po 'troppo costoso poiché la functionpiastra della caldaia è di almeno 9 byte, ma se si passa all'indicizzazione 0, possiamo fare 109 byte
Giuseppe,

1
Buona scoperta! Fino a 107, rendendosi conto che seq(a=l)può seq(l)durare fino a quando l'input ha almeno 2 elementi (ho chiesto se va bene).
Robin Ryder,


6

05AB1E , 9 byte

ΣN._ï}-_O

Provalo online!

Utilizza l'indicizzazione basata su 0.

Spiegazione:

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

6

Japt -x , 10 9 byte

0-based

í¶UñÈséYn

Provalo

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

4

Gelatina , 9 byte

Dṙ"JḌỤ=JS

Provalo online!

Collegamento monadico che accetta un elenco di numeri interi e restituisce un numero intero che indica il numero di numeri interi che rimangono in posizione dopo aver eseguito la rotazione utilizzando l'indicizzazione 1.

Spiegazione

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

4

Python 2 , 104 100 97 93 byte

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

Provalo online!

Indicizzazione basata su 0.

Prima ruota ogni numero, quindi confronta il risultato con il risultato, ma ordinato.


Salvato:

  • -3 byte, grazie a Erik the Outgolfer
  • -4 byte, grazie a Kevin Cruijssen (e al suo cambio di regole)


@eriktheoutgolfer grazie, ero troppo impegnato a provare a fare una lambda, di cui mi ero dimenticato input():)
TFeld

Ecco perché provo per la prima volta a creare un programma completo ...: D Seriamente, se provi prima a fare un programma completo, vedrai chiaramente se vale la pena convertirlo in lambda o no. Non iniziare defsubito (sono abbastanza inutili in Python 2, contrariamente a Python 3).
Erik the Outgolfer,

Ho permesso la lista di input come stringhe ora, quindi puoi eliminare 4 byte rimuovendo gli accenti gravi che circondano ils .
Kevin Cruijssen,

4

R , 90 88 85 byte

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

Provalo online!

Codice srotolato con spiegazione:

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
}


2

Stax , 11 10 byte

ìát'óJ♣á◄·

Esegui ed esegui il debug

Questo programma utilizza l'indicizzazione basata su 0 e accetta l'input come una matrice di stringhe. Ho salvato un byte sfruttando l'opportunità dei nuovi chiarimenti di input.


2

Perl 5 -pa , 80 byte

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

Provalo online!

Accetta input come numeri separati da spazio su STDIN; dà un risultato basato su 1.


2

Pyth , 15 byte

sqVSJ.ev.<`bkQJ

Provalo online! Utilizza l'indicizzazione basata su 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

@FryAmTheEggman Ora ho permesso un elenco di stringhe come input, quindi ora è valido.
Kevin Cruijssen,

@FryAmTheEggman Probabilmente hai ragione, non ho considerato l'ordinamento lessicale rispetto all'ordinamento intero quando ho omesso il s- la versione originale del codice aveva unv lo stesso effetto. Io modificare indietro in
Sok

Ah, come sottolinea Kevin ora, potresti rilasciare il backtick e prendere l'input come un elenco di stringhe per salvare un byte.
FryAmTheEggman,

2

APL + WIN, 23, 21 19 byte

2 byte salvati immettendo gli interi come vettore nidificato di caratteri

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

1 indicizzato.

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.

Provalo online! Per gentile concessione di Dyalog Classic


Non sono sicuro se salverebbe eventuali byte, ma ora ho consentito l'input come elenco di stringhe o elenco di elenchi di cifre.
Kevin Cruijssen,

@KevinCruijssen Grazie per averlo sottolineato. L'immissione di un vettore nidificato di stringhe consente di risparmiare 2 byte
Graham,

2

JavaScript (Node.js) , 107 99 95 byte

-8 byte Grazie @Shaggy per aver accettato l'array di stringhe. Ulteriori golfizzati 4 byte da questo. Questa volta non attiverà l'errore di 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

Provalo online!

JavaScript (Node.js) , 111 107 byte

-4 byte Grazie @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

Provalo online!

JavaScript (Node.js) , 113 111 byte

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

Provalo online!

0-indicizzati. Può innescare un errore di memoria per voci molto grandi.


2
99 byte , prendendo l'input come una matrice di stringhe intere.
Shaggy,

@Shaggy Grazie, e ora sono 95 byte;)
Shieru Asakoto

2

Perl 6 , 50 byte

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

Provalo online!

Indicizzazione basata su 0. Esposto anche un bug di Rakudo .

Spiegazione

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

2

PHP ,159 141 134 130 byte

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

Provalo online!

Indicizzazione in base zero.

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 byte prendendo input come array di stringhe, grazie a @KevinCruijssen per averlo sottolineato.

Non conosco troppo bene PHP, ma ora consento un elenco di stringhe anziché numeri interi, quindi penso che puoi rimuovere il .=''?
Kevin Cruijssen,

@KevinCruijssen hai ragione. Prendere come una matrice di stringhe rimuoverà ciò dall'essere necessario. Aggiornerò di conseguenza.
640 KB


2

Query T-SQL, 99 byte

Sql non ha un metodo di rotazione, quindi ho dovuto implementare la mia sintassi, poiché questa è una query, doveva essere eseguita senza loop.

Indicizzazione basata su 0.

Utilizzo di una variabile di tabella come input.

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

Provalo online


1

Icona , 141 byte

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

Provalo online!

Indicizzazione basata su 1


1

Perl 5 , 104 byte

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

Provalo online!

Indicizzazione basata su 0 in Perl. Ungolf e commentato:

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

1

Rubino -ap , 77 byte

1-indicizzati. Temp è stato eliminato in precedenza perché ho perso parte delle specifiche.

-plegge una riga di STDIN e restituisce $_alla fine. -adivide la linea di lettura per spazi e la salva come $F.

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

Provalo online!


puoi salvare 2 byte sostituendo [...].join.to_iconeval [...]*''
Maniglia

1
@Doorknob purtroppo no ... ci sono casi limite in cui se un numero viene ruotato per avere uno zero iniziale, evallo interpreterà come un numero di base 8, che potrebbe confondere i nostri conteggi ...
Value Ink

1

Wolfram Language (Mathematica) , 65 byte

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

Provalo online!

1-based. Prendiamo l'input come un elenco di elenchi di cifre, che funziona perché Mathematica ordina gli elenchi per lunghezza, quindi lessicograficamente, cioè proprio come i numeri originali.


1

Bash , 204 201 byte

L'unica cosa interessante qui (forse) è l'uso di eval. L'algoritmo è anche ingombrante in quanto crea un elenco ordinato, quindi lo legge per determinare l'indice / indici modificati.

Soluzione a 1 base. I miei ringraziamenti a @RobinRyder per l'utile algoritmo di rotazione.

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

Provalo online!

Codice rivisto dopo i commenti di Kevin; Provalo online!


Non conosco troppo bene Bash, ma penso che puoi rimuovere l'ultimo spazio tra ;}. Inoltre, puoi cambiare il tuo primo ciclo in for((i=0;++i<=$#;));.
Kevin Cruijssen,

@KevinCruijssen - di solito ho trovato che Bash e gli amici hanno bisogno di quello spazio per analizzare la riga di comando. In questa occasione hai ragione potrebbe essere rimosso. Bella idea per rifondare e pre-incrementare. 202 byte.
PJF

1

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

Provalo online!

0-indicizzati. 160 caratteri dopo aver rimosso rientri e newline. Questo stampa 6:

println( f(Seq("8","49","73","102","259","762","2782","3383","9217","37846","89487","7471788")) )
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.