Per "spostare" su un numero di nposti, procedi come segue:

• Rimuovi le ultime ncifre
• Aggiungi ncopie della prima cifra all'inizio del numero

Ad esempio, per spostare il numero di 31415tre posizioni, estrarre le ultime tre cifre da ottenere 31, quindi aggiungere altre tre copie della prima cifra 3, fino alla fine, dando 33331.

Se il numero è negativo, le cifre dovrebbero essere prese da sinistra, e la prima cifra dovrebbe essere "compilata" da destra. Ad esempio, la stringa 31415spostata su -3 posizioni dà 15555.

Se il numero è 0, non è necessario apportare modifiche.

Se lo spostamento è superiore alla lunghezza del programma, le cifre inserite potrebbero iniziare a essere rimosse. Ciò significa che se il numero indicato è superiore alla lunghezza della stringa, non verranno apportate ulteriori modifiche dopo che l'intera stringa diventa una singola cifra.

La sfida

Dati due numeri, ne s, il ritorno si nspostava sui sluoghi.

Casi test

   n,  s -> result
7243,  1 -> 7724
 452, -1 -> 522
  12,  1 -> 11
 153,  4 -> 111

Questo è code-golf , quindi vince l'invio valido più breve (misurato in byte).

APL (Dyalog) , 32 byte

Funzione anonima che accetta il setaccio come argomento a sinistra e il numero (come stringa) come argomento a destra.

{a←|⍺⋄(≢⍵)↑(a-⍺)↓(a⍴⊃⍵),⍵,a⍴⊃⌽⍵}

Provalo online!

{ funzione anonima in cui ⍺ e ⍵ sono argomenti destro e sinistro

 |⍺ il valore assoluto dello spostamento

 a← conservare in un

 ⋄ poi

 ⌽⍵ invertire il numero

 ⊃ scegli la prima (cioè l'ultima) cifra

 a⍴ r eshape a lunghezza una

 ⍵, anteporre il numero

 (... ), anteporre quanto segue:

  ⊃⍵ la prima cifra

  a⍴ r eshape a lunghezza una

 (... )↓ rilascia il seguente numero di caratteri:

  a-⍺ un meno il cambiamento

 (... )↑ prendi il seguente numero di caratteri:

  ≢⍵ la lunghezza del numero originale

Python 2 , 50 byte

lambda n,s:(n[0]*s+n+n[-1]*-s)[-s*(s<0):][:len(n)]

Provalo online!

Haskell, 69 byte

s#n|l<-[1..abs n]=take(length s)$drop(-2*n)$(s!!0<$l)++s++(last s<$l)

Prende il numero come una stringa. Provalo online!

Come funziona:

s#n                         -- s: input number as a string
                            -- n: shift amount

(s!!0<$l)++s++(last s<$l)   -- make a string:
                            -- n times the first digit, the whole number, n times the last digit
                            -- e.g. "567" 2 -> 5556777
drop(-2*n)                  -- drop the first (-2 * n) chars, i.e. 0 if n>0
take(length s)              -- take as may chars as there are in s

MATL , 12 byte

tn:i-yn1&Xl)

Gli input sono: numero da spostare come stringa; quantità di spostamento come un numero.

Provalo online! Oppure verifica tutti i casi di test .

Consisder input '452e '-1'.

t     % Implicitly input string. Duplicate
      % STACK: '452', '452'
n     % Number of elements
      % STACK: '452', 3
:     % Range
      % STACK: '452', [1 2 3]
i     % Input number
      % STACK: '452', [1 2 3], -1
-     % Subtract, element-wise
      % STACK: '452', [2 3 4]
y     % Duplicate from below
      % STACK: '452', [2 3 4], '452'
n     % Number of elements
      % STACK: '452', [2 3 4], 3
1     % Push 1
      % STACK: '452', [2 3 4], 3, 1
&Xl   % Clamp, with three inputs. Applies min function, then max
      % STACK: '452', [2 3 3]
)     % Reference indexing. Implicitly display
      % STACK: '522'

J, 37 byte

Questa era una di quelle situazioni in J in cui un verbo esplicito sembrava la scelta giusta (l'unica?), Ma mi piacerebbe sapere se c'è una tacita riscrittura di questo:

4 :'(-x)(|.!.((x>0)&{({:,{.)":y))":y'

Il verbo shift incorporato di J ti consente di configurare il carattere "fill":

|.!.f  NB. f is the fill character

La logica per determinare se utilizzare il primo o l'ultimo carattere come carattere di riempimento è semplice

(x>0)&{ ({: , {.)

Provalo online!

J , 23 byte

(_&(]{.,],{:)~|)}.~_2*]

L'ingresso n e l'output sono stringhe contenenti i numeri.

Provalo online!

Spiegazione

(_&(]{.,],{:)~|)}.~_2*]  Input: 'integer n' as a string (LHS), integer s (RHS)
(              )         Extend 'n' by copying its head and tail 's' times
              |            Abs(s)
 _&(]       )~             Nest 'Abs(s)' times on 'n'
          {:                 Tail
        ],                   Append the tail to itself
     {.                      Head
       ,                     Prepend the head to the previous
                   _2*]  Multiply 's' by -2
                }.~      Drop abs(-2*s) from the head if 's' < 0 else from the tail

Retina , 61 byte

\d+¶
$*1¶
+`(?<!-).¶(.)(.*).
¶$1$1$2
-

+`.¶.(.*)(.)$
¶$1$2$2

Provalo online!

05AB1E , 16 byte

0‹©iR}¹ÄF¨¬ì}®iR

Provalo online!

Spiegazione

0‹                 # input_1 is negative
  ©                # store a copy in register
   iR}             # if true (input_1 is negative), reverse input_2
      ¹ÄF          # abs(input_1) times do
         ¨         # remove the last element
          “       # prepend the head
            }      # end loop
             ®iR   # if input_1 was negative, reverse result

Python 2 , 87 byte

f=lambda n,s:s<0and f(n[::-1],-s)[::-1]or n[0]*min(len(n),s)+n[:[0,len(n)-s][len(n)>s]]

Provalo online!

Prende il numero come stringa e lo spostamento come numero intero. Restituisce una stringa.

Ho provato a incorporare l'inversione all'interno della funzione piuttosto che effettuare una chiamata ricorsiva, ma non riuscivo a farlo bene.

Python 3 , 73 byte

f=lambda s,i:(f(s+1,i[1:]+i[-1])if s<0else f(s-1,i[0]+i[:-1]))if s else i

Provalo online!

Haskell , 108 byte

Oh bene, questo è andato peggio di quanto pensassi ..

n#s=print$show n&s
r=reverse
n&s|s<0=r$r n&abs s|(a:b,c)<-splitAt s n=take(length n)$(a<$[0..s])++b++c|1>0=n

Provalo online!

Ungolfed

n # s = print $ show n & s
n & s
  | s < 0                = reverse (reverse n & abs s)
  | (a:b,c)<-splitAt s n = take (length n) (replicate s a ++ b ++ c)
  | otherwise            = n

Clojure, 121 byte

#(let[T(if(pos? %2)reverse vec)](apply str(concat(repeat %2(first %))(T(drop(Math/abs %2)(T %)))(repeat(- %2)(last %)))))

Ouch, brutto anche per gestire input negativi.

Pyth, 28 byte

AQ=Y<+*hJ?K<0H`G_`GHJlJ?KY_Y

Provalo online o prova alcuni input

Spiegazione

AQ=Y<+*hJ?K<0H`G_`GHJlJ?KY_Y
AQ                           | Split Q into 2 parts, G and H.
        J?K<0H`G_`G          | If 0 < H, J = str(G). Else, J = reverse(str(G)). Return J
       h                     | Find 1st element
      *            H         | Repeat H times
     +              J        | Concatenate with J
    <                lJ      | Find 1st length(J) elements
  =Y                         | Assign to Y.
                       ?KY_Y | If K, implicit print Y. Else implicit print reverse(Y).

05AB1E , 33 byte

ÄF¹0‹©i¨ë¦}}²®i¤ë¬}sg¹Ä‚Ws\×®i«ëì

Provalo online!

05AB1E non è così caldo con i condizionali.

JavaScript, 80 byte

(n,s,k=n.length,p=s<=0)=>n.slice(p*-s,p?k:-s)[p?"padEnd":"padStart"](k--,n[p*k])

Prende l'input come rappresentazione in forma di stringa del numero e importo numerico di "spostamento". Restituisce una stringa.

Test snippet

let f=
(n,s,k=n.length,p=s<=0)=>n.slice(p*-s,p?k:-s)[p?"padEnd":"padStart"](k--,n[p*k])

I.value="31415";J.value="3";D.oninput()

<div id=D oninput="O.value=I.value.length&J.value.length?f(I.value,+J.value):''">n: <input id=I size=10> s: <input id=J size=2><br><input id=O disabled>