शिफ्टर बनाएं

Question

कई nस्थानों पर "शिफ्ट" करने के लिए, निम्नलिखित करें:

• अंतिम nअंक निकालें
• nसंख्या की शुरुआत में पहले अंक की प्रतियां जोड़ें

उदाहरण के लिए, नंबर 31415तीन स्थानों को स्थानांतरित करने के लिए 31, प्राप्त करने के लिए अंतिम तीन अंक निकालें , और फिर पहले अंक की तीन और प्रतियां जोड़कर, 3अंत में दें 33331।

यदि संख्या नकारात्मक है, तो अंकों को बाईं ओर से लिया जाना चाहिए, और पहला अंक दाईं ओर से "भरा" होना चाहिए। उदाहरण के लिए, 31415-3 स्थानों पर स्थानांतरित स्ट्रिंग देता है 15555।

यदि संख्या 0 है, तो कोई परिवर्तन नहीं किया जाना चाहिए।

यदि शिफ्ट कार्यक्रम की लंबाई से अधिक है, तो जो अंक भरे गए थे, वे हटाए जाने शुरू हो सकते हैं। इसका मतलब है कि यदि दी गई संख्या स्ट्रिंग की लंबाई से अधिक है, तो पूरे स्ट्रिंग के एकल अंक बनने के बाद कोई और बदलाव नहीं किया जाएगा।

चुनौती

दो नंबरों को देखते हुए, nऔर s, स्थानों nपर वापस आ गए s।

परीक्षण के मामलों

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

यह कोड-गोल्फ है , इसलिए सबसे कम वैध जमा (बाइट्स में मापा गया) जीतता है।

Comments

जीतने की कसौटी क्या है?

— मिस्टर एक्सकोडर

मुझे नहीं लगता कि मैं समझता हूं कि "शिफ्टिंग" क्या करता है। इसे [बाइनरी] टैग किया गया है, जिससे मुझे लगता है कि इसका बाइनरी शिफ्ट्स के साथ कुछ करना है। शायद यह परीक्षण के मामलों में बाइनरी में संख्याओं को प्रदर्शित करने में भी मदद करेगा?

— फलों का जूस

यह शिफ्टिंग और "स्ट्रेचिंग" पहला या आखिरी अंक है। क्या अस्पष्ट है?

— लुइस मेंडू

हाँ, यह बहुत स्पष्ट है कि वे क्या पूछ रहे हैं

— wrmug

स्थानांतरण को अच्छी तरह से परिभाषित किया गया है: आधार की शक्ति द्वारा पूर्णांक गुणन या विभाजन। लेकिन परीक्षण मामलों में से कोई भी काम नहीं करता है, इसलिए यह प्रश्न एक idiosyncratic परिभाषा का उपयोग करता है और यह नहीं कहता कि यह क्या है।

— पीटर टेलर

Answer 1

APL (Dyalog) , 32 बाइट्स

बेनामी फ़ंक्शन जो झारखंड को बाएं तर्क के रूप में लेता है और संख्या (स्ट्रिंग के रूप में) को सही तर्क के रूप में।

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

इसे ऑनलाइन आज़माएं!

{ अनाम फ़ंक्शन जहां ments और and बाएँ और दाएँ तर्क हैं

 |⍺ पारी का पूर्ण मूल्य

 a← में दुकान एक

 ⋄ फिर

 ⌽⍵ संख्या उल्टा

 ⊃ पहला (यानी अंतिम) अंक चुनें

 a⍴ r इसे लम्बाई तक बढ़ाएं a

 ⍵, संख्या पूर्व निर्धारित करें

 (… ), निम्नलिखित को प्रस्तुत करें:

  ⊃⍵ पहला अंक

  a⍴ r इसे लम्बाई तक बढ़ाएं a

 (… )↓ वर्णों की निम्न संख्या छोड़ें:

  a-⍺ एक शून्य से पारी

 (... )↑ निम्नलिखित वर्णों की संख्या लें:

  ≢⍵ मूल संख्या की लंबाई

Answer 2

अजगर 2 , 50 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 3

हास्केल, 69 बाइट्स

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

संख्या को एक स्ट्रिंग के रूप में लेता है। इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है:

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

Answer 4

MATL , 12 बाइट्स

tn:i-yn1&Xl)

इनपुट्स हैं: एक स्ट्रिंग के रूप में स्थानांतरित होने वाली संख्या; एक नंबर के रूप में स्थानांतरण की राशि।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

Consisder आदानों '452और '-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'

Comments

यह अब तक कम से कम बाइट्स अच्छी नौकरी है!

— के स्प्लिट X

@KSplitX धन्यवाद! BTW I ने केवल एक स्पष्टीकरण जोड़ा

— लुइस मेंडो

Answer 5

जे, 37 बाइट्स

यह जम्मू में उन स्थितियों में से एक था जहां एक स्पष्ट क्रिया सही (एकमात्र?) पसंद की तरह लग रही थी, लेकिन मुझे यह जानना अच्छा लगेगा कि क्या इसका कोई टैक्स्ट रीराइट है:

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

J का शिफ्ट क्रिया में बनाया गया है जिससे आप "भरण" वर्ण को कॉन्फ़िगर कर सकते हैं:

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

यह निर्धारित करने के लिए तर्क है कि भरण चरित्र के रूप में पहले या अंतिम चार का उपयोग करना है या नहीं

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

इसे ऑनलाइन आज़माएं!

Answer 6

जे , 23 बाइट्स

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

इनपुट n और आउटपुट संख्याओं वाले स्ट्रिंग्स हैं।

इसे ऑनलाइन आज़माएं!

व्याख्या

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

Comments

सुंदर। मुझे शक था कि मेरा एक बेहतर दृष्टिकोण था ...

— जोनाह

हालांकि मैं आपको एक स्ट्रिंग के रूप में n नोटिस करता हूं, जो (संभवतः गलत तरीके से) आईडी मान लिया गया था। हालांकि इसने मुझे केवल 4 वर्णों को बचाया होगा ...

— योना

Answer 7

रेटिना , 61 बाइट्स

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

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

इसे ऑनलाइन आज़माएं!

Answer 8

05AB1E , 16 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

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

Answer 9

पायथन 2 , 87 बाइट्स

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

इसे ऑनलाइन आज़माएं!

संख्या को स्ट्रिंग के रूप में लेता है, और पूर्णांक के रूप में शिफ्ट। एक स्ट्रिंग लौटाता है।

मैंने एक पुनरावर्ती कॉल करने के बजाय फ़ंक्शन के अंदर उलटफेर करने की कोशिश की, लेकिन मैं इसे ठीक से प्राप्त नहीं कर पाया।

Answer 10

पायथन 3 , 73 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 11

हास्केल , 108 बाइट्स

ओह ठीक है, इससे भी बदतर मैंने सोचा था ..

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

इसे ऑनलाइन आज़माएं!

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

Answer 12

क्लोजर, 121 बाइट्स

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

आउच, नकारात्मक इनपुट से निपटने के लिए बुरा भी।

Answer 13

पायथ, 28 बाइट्स

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

इसे ऑनलाइन आज़माएं या कुछ इनपुट का परीक्षण करें

व्याख्या

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

Answer 14

05AB1E , 33 बाइट्स

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

इसे ऑनलाइन आज़माएं!

---

05AB1E सशर्त के साथ इतना गर्म नहीं है।

Answer 15

जावास्क्रिप्ट, 80 बाइट्स

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

संख्या के एक स्ट्रिंग प्रतिनिधित्व और एक संख्यात्मक "शिफ्ट" राशि के रूप में इनपुट लेता है। एक स्ट्रिंग लौटाता है।

टेस्ट स्निपेट

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>