L'obiettivo

Questa è una sfida semplice. L'input è una singola stringa non vuota, contenente solo cifre 0123456789e hash #. Conterrà esattamente una serie di cifre, che codifica un numero intero non negativo e può avvolgere la fine della stringa e almeno una #. L'intero può avere zero iniziali. Ad esempio, ##44##, 013####e 23###1sono validi input, mentre ###, 0099e #4#4non lo sono.

Il tuo compito è estrarre il numero intero ndalla stringa e generare i npassaggi ruotati della stringa verso destra.

Esempi

• L'ingresso #1##deve essere ruotato di 1 passo verso destra, quindi l'uscita corretta è ##1#.
• L'ingresso #026###deve essere ruotato di 26 passi verso destra, poiché lo 0 iniziale viene ignorato. L'output corretto è 26####0.
• L'input 1####2contiene l'intero 21 avvolto sull'estremità, quindi dovrebbe essere ruotato di 21 passi verso destra. L'output corretto è ##21##.

Regole e punteggio

È possibile scrivere un programma completo o una funzione. Vince il conteggio di byte più basso e non sono consentite scappatoie standard.

Puoi presumere che il numero si nadatti al inttipo standard della tua lingua. Al contrario, se quel inttipo standard implementa numeri interi di precisione arbitraria, è necessario supportare (in teoria) un valore arbitrariamente grande n.

Casi test

#1## -> ##1#
##4## -> #4###
1####1 -> ####11
1####2 -> ##21##
#026### -> 26####0
#000### -> #000###
###82399 -> ##82399#
51379#97 -> #9751379
#98##### -> ###98###
#######4## -> #4########
60752#1183 -> 8360752#11
####99366800## -> 366800######99
########9##### -> ###9##########
91#####515694837 -> 1#####5156948379
###6114558###### -> #6114558########
######219088736090042#### -> 9088736090042##########21
#46055080150577874656291186550000138168########### -> 0138168############4605508015057787465629118655000
568375993099127531613012513406622393034741346840434468680494753262730615610086255892915828812820699971764142551702608639695081452206500085233149468399533981039485419872101852######################3680 -> 99533981039485419872101852######################36805683759930991275316130125134066223930347413468404344686804947532627306156100862558929158288128206999717641425517026086396950814522065000852331494683

CJam, 11 byte

q_'#%W%sim>

Provalo online! o verifica tutti i casi di test .

Si noti che questo non funzionerà negli ultimi due casi di test, poiché i numeri coinvolti non si adattano a 64 bit.

Come funziona

q_          e# Read all input and push it twice.
  '#%       e# Split at runs of '#'.
     W%     e# Reverse the resulting array.
       si   e# Cast to string, then to int.
         m> e# Rotate the original input that many places to the right.

Julia, 71 65 byte

s->join(circshift([s...],maximum(parse,split(s*s,"#",keep=1<0))))

Questa è una funzione anonima che accetta una stringa e restituisce una stringa. Per chiamarlo, assegnarlo a una variabile.

Aggiungiamo l'input a se stesso, lo dividiamo in un array con #come separatore, analizziamo ogni numero intero e prendiamo il massimo. Questo definisce il numero di volte in cui spostiamo la stringa verso destra. Dividiamo la stringa in una Charmatrice, la spostiamo e joinla rimettiamo insieme.

Python, 66 byte

lambda l:(2*l)[-int(''.join(l.split('#')[::-1]))%len(l):][:len(l)]

Retina, 65 57 49

(\ D *) # * (\ d +)
$ 2 $ 1 $ 0
^ \ D +
$ *
+ `1 (. *) (.)
 $ 2 $ 1
<Spazio>

Risparmiato 8 byte grazie a Martin!

Provalo online!

Si noti che questo esaurirà / esaurirà la memoria per i casi di test online di grandi dimensioni, e sulla maggior parte dei computer sani, per alcuni dei più grandi.

Questo prende l'ultimo numero nella stringa e il primo o nessun numero nella stringa e li mette davanti alla stringa. Quindi converte quel numero combinato in unario e ruota ripetutamente mentre si rilascia una cifra unaria.

Gelatina, 12 10 byte

ẋ2~ṣ0‘ḌṂṙ@

Provalo online! o verifica tutti i casi di test .

sfondo

Di 'che l'ingresso è 51379#97.

Ripetendo due volte la stringa ( 51379#9751379#97), possiamo assicurarci che conterrà una rappresentazione contigua del numero.

Successivamente, applichiamo bit a bit NOT a tutti i caratteri. Questo tenta di eseguire il cast su int, quindi '1' viene valutato su 1 , quindi mappato su ~ 1 = -2 . In caso di errore ( #), restituisce 0 .

Per il nostro esempio, questo dà

[-6, -2, -4, -8, -10, 0, -10, -8, -6, -2, -4, -8, -10, 0, -10, -8]

Successivamente, abbiamo diviso a zero per separare la parte che codifica il numero dal resto.

[[-6, -2, -4, -8, -10], [-10, -8, -6, -2, -4, -8, -10], [-10, -8]]

Bitwise NON mappa da n a -n - 1 , quindi incrementiamo ciascuno per ottenere -n .

[[-5, -1, -3, -7, -9], [-9, -7, -5, -1, -3, -7, -9], [-9, -7]]

Quindi, convertiamo ogni elenco dalla base 10 all'intero.

[-51379, -9751379, -97]

Il numero più basso è il negativo di quello che stiamo cercando. Poiché l'atomo di rotazione dell'elenco Jelly ṙruota a sinistra , questo evita di moltiplicare per -1 per ruotare a destra.

Come funziona

ẋ2~ṣ0‘ḌṂṙ@  Main link. Input: S (string)

ẋ2          Repeat the string twice.
  ~         Apply bitwise NOT to all characters.
            This maps 'n' to ~n = -(n+1) and '# to 0.
   ṣ0       Split at occurrences of zeroes.
     ‘      Increment all single-digit numbers.
      Ḍ     Convert each list from base 10 to integer.
       Ṃ    Take the minimum.
        ṙ@  Rotate S that many places to the left.

MATL , 28 25 17 16 byte

!G1Y4XXPZcXvUYS!

8 byte in meno prendendo in prestito l'idea di Dennis di dividere l'array e invertire l'ordine dei pezzi

Gli ultimi due casi di test non funzionano perché il numero è troppo grande.

EDIT (20 maggio 2016) Il codice nel link utilizza Xzinvece di Xv, a causa di recenti cambiamenti nella lingua.

Provalo online!

!         % take implicit input: string. Transpose into column char array
G         % push input string again
1Y4       % predefined literal '\d' (for regexp)
XX        % match regexp. Gives cell array with 1 or 2 strings
P         % flip that array
ZcXv      % join the strings in that array, without spaces
U         % convert to number
YS        % rotate the transposed input that many times
!         % put back into row form (string). Implicitly display

PowerShell, 153 byte

_{(Ma vedi la sezione Credito extra, sotto)}

param($a)$d=[System.collections.arraylist][char[]]$a;for($b=+("$a$a"-split"#"-ne'')[1];$b;$b--){$r=$d[-1];$d.removeAt($d.Count-1);$d.insert(0,$r)}-join$d

PowerShell non ha il concetto di "spostare" un array, quindi ho dovuto implementare la mia soluzione. Richiederà molto tempo per numeri più grandi, ma alla fine dovrebbe completare tutto ciò che si adatta a un int a 32 bit.

Accetta input $ae imposta una nuova variabile $dcome oggetto [System.Collections.ArrayList] . Questo viene fatto perché, tecnicamente, le matrici in PowerShell sono immutabili _{(ulteriormente spiegate di seguito in Credito extra)} e quindi non supportano inserimenti o rimozioni arbitrari, necessari per lo spostamento. Quindi, entriamo in un forciclo.

La condizione iniziale è un trucco che ho trovato: se concateniamo l'input insieme, ci dividiamo #e ignoriamo i vuoti, il secondo elemento dell'array risultante sarà uguale al nostro numero, indipendentemente dal wrapping. Lo impostiamo su $be diminuiamo $bogni volta fino a zero.

Ad ogni iterazione, impostiamo l'helper $rcome ultimo elemento nell'arraylist, rimuoviamo quell'ultimo elemento e quindi inseriamo l'elemento in primo piano ... "spostando efficacemente l'array a destra di un elemento.

Infine, abbiamo semplicemente emesso in -join$dmodo che sia concatenato in una stringa.

Credito extra

Se il problema stava spostando l'array a sinistra anziché a destra , possiamo farlo in modo significativamente più breve usando l'assegnazione multipla . Fondamentalmente, "Se il valore di assegnazione contiene più elementi che variabili, tutti i valori rimanenti vengono assegnati all'ultima variabile."

In sostanza, questo significa qualcosa di simile $c=@(1,2,3)e $a,$b=$c
avrà $a=1un int e $b=@(2,3)un array.

PowerShell, 90 byte, esegue uno spostamento a sinistra anziché uno a destra

param($a)$b=+("$a$a"-split"#"-ne'')[1];$a=[char[]]$a;for(;$b;$b--){$r,$a=$a;$a+=$r}-join$a

Qui prendiamo ancora una volta input e impostiamo $bcome sopra. Effettuiamo nuovamente il cast $acome char-array, quindi entriamo nello stesso forloop di cui sopra. Questa volta, tuttavia, non abbiamo bisogno di supportare la rimozione / inserzione arbitraria, quindi non abbiamo bisogno di usare l' [System.Collections.ArrayList]oggetto costoso , né le costose chiamate al metodo. Invece semplicemente impostiamo $rdi essere il primo elemento di $a, e gli elementi rimanenti vengono nuovamente salvati $a. Quindi dobbiamo +=rimetterlo alla fine.

(Come ho detto, gli array di PowerShell sono tecnicamente immutabili, ma l' +=operatore qui è sovraccarico: prende un array e un altro oggetto, li mette insieme (termine tecnico) in un nuovo array, lo restituisce e lo salva come nome della variabile e lo distrugge l'array originale. Funzionalmente, abbiamo appena aggiunto un elemento alla fine dell'array, ma tecnicamente (e dal punto di vista della memoria / della spazzatura, ecc.) è un array nuovo di zecca. Questo può ovviamente diventare un'operazione costosa se l'array è grande o complesso. Il rovescio della medaglia è che, poiché gli array sono immutabili, indicizzarli o iterare su di essi è molto economico.)

L'output rimane la stessa azione, con -joinun'istruzione per trasformarlo in una singola stringa.

Scherzi a parte, 21 byte

,;;+'#@s`≈`MM@#@`/`nΣ

Provalo online!

Attenzione: questa soluzione è molto inefficiente, quindi i casi di test più grandi scadranno su TIO. Usa l'interprete locale.

Spiegazione:

,;;+'#@s`≈`MM@#@`/`nΣ
,;;+                   make 3 copies of input, and concatenate two of them
    '#@s               split on #s
        `≈`MM          convert strings to ints, take maximum
             @#@       explode final copy of input
                `/`n   rotate to the right n times
                    Σ  join

Mathematica, 69 byte

#~StringRotateRight~ToExpression[""<>Reverse@TextCases[#,"Number"]]&

Trova sequenze di numeri in, se ce ne sono 2, il loro ordine deve essere invertito. Concatena le stringhe (se è solo una, restituisce solo la stringa numerica). Converti la stringa in numerica e ruota la stringa quel numero di volte.

Pyth, 22 14 byte

.>zs-.<zxz\#\#

Provalo qui!

Spiegazione

.> zs -. <zxz \ # \ # # z = input

     . <z # ruota z lasciato da
        xz \ # # indice della prima occorrenza di un hash
                  # questo assicura che il numero intero non sia avvolto attorno alla fine
    - \ # # filtra tutti gli hash
   s # cast su un numero intero, rimuove anche gli zeri iniziali
.> z # esegue il roation finale della stringa di input e la stampa

Funziona con tutti i test e anche Almosts finisce all'istante per numeri molto grandi.

JavaScript (ES6) 66

Per una volta, lo stupido negativo %di javascript per i numeri negativi diventa utile

z=>(z+z).substr(-(l=z.length,[a,b]=z.match(/\d+/g),b?b+a:a)%l-l,l)

Pyth, 10 byte

.>zss_cz\#

Provalo online. Suite di test.

Questa è una traduzione della risposta CJam di Dennis . Lo sto trasformando in un wiki della comunità, dal momento che non l'ho inventato.

Spiegazione

      cz\#   split input at #
     _       reverse
    s        join
   s         cast to integer
.>z          rotate input right

JavaScript (ES6), 67 64 byte

s=>(l=s.length,s+s).substr(l-s.split(/#+/).reverse().join``%l,l)

Un altro porto della risposta CJam di Dennis.

Modifica: salvato 3 byte appropriandosi della parte della risposta di edc65 a cui non ha attirato l'attenzione.

Perl 5, 41 byte

39 byte più due per i -lFflag ( -M5.01è gratuito):perl -lF -M5.01 script.pl

/#+/;map{unshift@F,pop@F}1..$'.$`;say@F

Spiegazione:

• -lFlegge l'input, rimuove la nuova riga finale, inserisce il resto nella stringa $_, lo divide in caratteri e lo inserisce nell'array @F.
• /#+/trova la prima stringa di #s in $_e imposta $`uguale alla roba precedente e $'uguale alla roba successiva. Se $`è vuoto, $'potrebbe contenere più #s. Tuttavia, $'.$`è una stringa la cui sottostringa iniziale è il numero di volte in cui ruotare l'array.
• Ora costruiamo la lista 1..$'.$`, che tratta $'.$`come un numero intero e quindi lo numera, che rimuove qualsiasi #s finale , quindi la lista va dal 1numero di volte per ruotare l'array.
• Per ogni elemento in quell'elenco, ruotiamo l'array ( popl'ultimo elemento e unshiftall'inizio).
• Quindi saytutti gli elementi dell'array ruotato.

Rubino - 68 72 70 byte

s=ARGV[0]
p s.split(//).rotate(-(s+s).scan(/\d+/).map(&:to_i).max)*""

• split converte la stringa in un array
• (s+s).scan(/\d+/) concatena la stringa a se stessa e ottiene una matrice di numeri (come stringhe)
• map(&:to_i) converti le stringhe in ints
• max scegli il più grande int
• rotate max volte
• *""riconvertire l'array in una stringa (abbreviazione di join)

Utilizzo: ruby scriptname.rb "[string]"

05AB1E , 14 13 byte

Bene, è molto improbabile che il codice termini per numeri superiori a 100000, ma se sei abbastanza paziente, ci sarà un risultato :). Codice:

'#¡rJ¹sF¤rS\J

Spiegazione:

'#¡             # Split the input on '#'
   r            # Reverse the stack
    J           # Join the stack
     ¹          # Take the first input
      s         # Swap with the number
       F        # For N in range(0, number), do...
        ¤       #   Obtain the last character
         r      #   Reverse the stack
          S     #   Split everything to individual characters
           \    #   Delete the last character
            J   #   Join the stack

Provalo online!

Utilizza la codifica CP-1252

VBSCRIPT, 82 99 BYTES

il codice precedente non gestiva i casi con il numero spostato alla fine

b=len(a):f=replace(a,"#","/",1,1):c=replace(split(f&f,"/")(1),"#",d) mod b:d=right(a,c)&left(a,b-c)

UNGOLFED

b=len(a)                                 -a->implicit input, get its length 
f=replace(a,"#","/",1,1)  -replace first instance of # so we can split later
c=replace(split(f&f,"/")(1),"#",d) mod b    -get the number and calc the mod
d=right(a,c)&left(a,b-c)                    -d->implicit output

questo tipo fa schifo ... c'è probabilmente un modo migliore per farlo, anche in VBscript

Mathematica, 73 58 byte

#~StringRotateRight~Max[FromDigits/@StringSplit[#<>#,"#"]]&

Molto byte. 15 byte salvati grazie a IPoiler

Matlab (73)

  @(a)regexprep(a,'(\d*)#*(\d*)#*','${circshift($0,[0 str2num([$2 $1])])}')

• Questo sta usando un altro approccio che mi chiedo se @luis l'abbia usato, perché facendo riferimento alla sua descrizione ci sono alcuni punti in comune mentre (un)? Fortunatamente non capisco il linguaggio Matl ritagliato.

matlab (86) 72

 @(n)circshift(n,[0 str2num(circshift(n(n~='#'),[0,-find(n=='#',1)+1]))])

• La funzione totalizza la stringa due volte, una volta per l'estrazione di numeri interi, seconda per l'attività desiderata, non impiega troppo tempo perché matlab procede a ruotare con (Dim)modulus(Length)l'eccezione che cade in un errore di segmentazione per intervalli più grandi.

• Farò fatica a giocare a golf di più ....

(86)

  @(n)circshift(n,[0 str2num([strtok(n(find(n=='#',1,'last'):end),'#') strtok(n,'#')])])

• La differenza tra questa funzione e la precedente, questa concatena due occorrenze distanti di numeri interi all'indietro, mentre la prima la ruota semplicemente.