10

Pour "décaler" sur plusieurs nemplacements, procédez comme suit:

Supprimer les derniers nchiffres
Ajoutez des ncopies du premier chiffre au début du numéro

Par exemple, pour déplacer le nombre de 31415trois, retirez les trois derniers chiffres pour obtenir 31, puis ajoutez trois autres copies du premier chiffre,, 3à la fin, en donnant 33331.

Si le nombre est négatif, les chiffres doivent être pris à gauche à la place et le premier chiffre doit être "rempli" à partir de la droite. Par exemple, la chaîne 31415décalée de -3 places donne 15555.

Si le nombre est 0, aucune modification ne doit être effectuée.

Si le décalage est supérieur à la durée du programme, alors les chiffres qui ont été remplis peuvent commencer à être supprimés. Cela signifie que si le nombre donné est supérieur à la longueur de la chaîne, aucune autre modification ne sera apportée après que la chaîne entière deviendra un seul chiffre.

Le défi

Étant donné deux nombres, net s, le retour a nchangé de splace.

Cas de test

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

Il s'agit de code-golf , donc la soumission valide la plus courte (mesurée en octets) l'emporte.

code-golf math K Split X
la source

Quel est le critère gagnant?

M. Xcoder

5

Je ne pense pas comprendre ce que fait le "déplacement". C'est tagué [binaire], ce qui me fait penser que cela a quelque chose à voir avec les décalages binaires. Peut-être qu'il serait utile d'afficher également les nombres en binaire dans les cas de test?

Esolanging Fruit

2

C'est déplacer et "étirer" le premier ou le dernier chiffre. Qu'est-ce qui n'est pas clair?

Luis Mendo

2

ouais c'est assez clair ce qu'ils demandent

wrymug

3

Le décalage est bien défini: multiplication ou division entière par une puissance de la base. Mais aucun des cas de test ne fonctionne, donc cette question semble utiliser une définition idiosyncratique et ne pas dire ce que c'est.

Peter Taylor

2

APL (Dyalog) , 32 octets

Fonction anonyme qui prend le crible comme argument de gauche et le nombre (comme chaîne) comme argument de droite.

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

Essayez-le en ligne!

{ fonction anonyme où ⍺ et ⍵ sont des arguments gauche et droit

|⍺ la valeur absolue du décalage

a← stocker dans un

⋄ puis

⌽⍵ inverser le nombre

⊃ choisir le premier (c'est-à-dire le dernier) chiffre

a⍴ r Eshape à la longueur d' un

⍵, ajouter le numéro

(… ), Ajoutez ce qui suit:

⊃⍵ le premier chiffre

a⍴ r Eshape à la longueur d' un

(… )↓ Supprimez le nombre de caractères suivant:

a-⍺ un moins le décalage

(… )↑ Prenez le nombre de caractères suivant:

≢⍵ la longueur du numéro d'origine

Adam
la source

2

Python 2 , 50 octets

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

Essayez-le en ligne!

Chas Brown
la source

2

Haskell, 69 octets

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

Prend le nombre sous forme de chaîne. Essayez-le en ligne!

Comment ça fonctionne:

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

nimi
la source

2

MATL , 12 octets

tn:i-yn1&Xl)

Les entrées sont les suivantes: nombre à décaler sous forme de chaîne; quantité de décalage en nombre.

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Entrées Consisder '452et '-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'

Luis Mendo
la source

1

C'est de loin le moins d'octets bon travail!

K Split X

@KSplitX Merci! BTW Je viens d'ajouter une explication

Luis Mendo

1

J, 37 octets

C'était l'une de ces situations en J où un verbe explicite semblait être le bon (le seul?) Choix, mais j'aimerais savoir s'il y a une réécriture tacite de ceci:

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

Le verbe shift intégré de J vous permet de configurer le caractère "fill":

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

La logique pour déterminer s'il faut utiliser le premier ou le dernier caractère comme caractère de remplissage est simple

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

Essayez-le en ligne!

Jonas
la source

1

J , 23 octets

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

L'entrée n et la sortie sont des chaînes contenant les nombres.

Essayez-le en ligne!

Explication

(_&(]{.,],{:)~|)}.~_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

miles
la source

beau. je soupçonnais qu'il y avait une meilleure approche que la mienne ...

Jonah

bien que je remarque que vous prenez n comme une chaîne de caractères qui (peut-être incorrectement) a supposé qu'il n'était pas autorisé. même si cela ne m'aurait épargné que 4 caractères ...

Jonah

1

Rétine , 61 octets

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

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

Essayez-le en ligne!

ovs
la source

1

05AB1E , 16 octets

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

Essayez-le en ligne!

Explication

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

Emigna
la source

0

Python 2 , 87 octets

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]]

Essayez-le en ligne!

Prend le nombre comme une chaîne et le décalage comme un entier. Renvoie une chaîne.

J'ai essayé d'incorporer l'inversion à l'intérieur de la fonction plutôt que de faire un appel récursif, mais je n'arrivais pas à faire les choses correctement.

musicman523
la source

0

Python 3 , 73 octets

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

Essayez-le en ligne!

wrymug
la source

0

Haskell , 108 octets

Eh bien, cela a empiré ce que je pensais ..

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

Essayez-le en ligne!

Non golfé

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

ბიმო
la source

0

Clojure, 121 octets

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

Aïe, méchant pour faire face aux entrées négatives aussi.

NikoNyrh
la source

0

Pyth, 28 octets

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

Essayez-le en ligne ou testez certaines entrées

Explication

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

K Zhang
la source

0

05AB1E , 33 octets

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

Essayez-le en ligne!

05AB1E n'est pas si chaud avec des conditions.

Urne de poulpe magique
la source

0

JavaScript, 80 octets

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

Prend l'entrée comme une représentation sous forme de chaîne du nombre et d'une valeur numérique de «décalage». Renvoie une chaîne.

Extrait de test

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>

Développer l'extrait

Justin Mariner
la source

Créer un levier de vitesses

Le défi

Cas de test

Réponses:

APL (Dyalog) , 32 octets

Python 2 , 50 octets

Haskell, 69 octets

MATL , 12 octets

J, 37 octets

J , 23 octets

Explication

Rétine , 61 octets

05AB1E , 16 octets

Python 2 , 87 octets

Python 3 , 73 octets

Haskell , 108 octets

Non golfé

Clojure, 121 octets

Pyth, 28 octets

05AB1E , 33 octets

JavaScript, 80 octets

Extrait de test