19

चुनौती

कभी उन फिल्म के ट्रेलर टाइटल (जैसे मार्टियन, इंटरस्टेलर, आदि) देखे गए हैं, जहां उन्हें अक्षरों के बीच में धीरे-धीरे फैलते हुए भारी अंतराल है?

पत्र के बीच में उचित मात्रा में रिक्त स्थान डालकर, एक स्ट्रिंग, गैप गुणक और दिशा दिए गए इस प्रभाव को फिर से बनाना चुनौती है।

उदाहरण

इनपुट : 'इंटरस्टेलर', गैप गुणक: 1.0, दिशा: आवक बढ़ रही है

Output: I N  T   E    R     S      T     E    L   L  A R

रिक्ति है: [1, 2, 3, ..., 3, 2, 1]; के साथ रिक्त स्थान की जगह '।' बेहतर रिक्ति को प्रदर्शित करने के लिए:

I.N..T...E....R.....S......T.....E....L...L..A.R

इनपुट : 'इंटरस्टेलर', गैप गुणक: 0.5, दिशा: आवक बढ़ रही है

Output: IN T E  R  S   T  E  L L AR

अंतर 0.5 से गुणा किया जाता है, इसलिए हम पूर्णांक विभाजन से [0, 1, 1, 2, ... 2, 1, 1, 0] प्राप्त करते हैं; '' का उपयोग कर:

IN.T.E..R..S...T..E..L.L.AR

इनपुट : 'CODEGOLF', गैप मल्टीप्लायर: 2.0, डायरेक्शन: इनकाउंटरिंग आउटवर्ड

Output: C        O      D    E  G    O      L        F

रिक्ति को 2 से गुणा किया जाता है, बाहर की ओर बढ़ता है, इसलिए हमें [8,6,4,2,4,6,8] मिलते हैं; की जगह '।':

C........O......D....E..G....O......L........F

इनपुट : 'CODEGOLF', गैप मल्टीप्लायर: 0.4, दिशा: बाहरी वृद्धि

Output: C O DEGO L F

अंतर को 0.4 से गुणा किया जाता है, बाहर की ओर बढ़ता है, इसलिए हमें [1,1,0,0,0,1,1] मिलता है; की जगह '।':

C.O.DEGO.L.F

नियम

3 इनपुट लेता है: स्ट्रिंग, गैप गुणक और दिशा
यदि इनपुट स्ट्रिंग लंबाई में विषम है (# अंतराल में भी) जैसे 'हेलो', तो आंतरिक सबसे अधिक 2 अंतराल का अंतर समान होना चाहिए H E L L O
आप चाहते हैं कि दिशा और अंतराल गुणक को पार्स किया जा सकता है, जैसे आप -2 का उपयोग '2 के गुणक के साथ आवक में वृद्धि' के रूप में कर सकते हैं, 1 के रूप में '1 के गुणक के साथ बाहर की ओर बढ़ते' आदि।
यह केवल रिक्त स्थान का उपयोग करने के लिए आवश्यक है, हालांकि यह एक बोनस है यदि चरित्र भरने योग्य है।

संदर्भ एनीमेशन

संदर्भ gif

मज़ा गोल्फ है!

code-golf string ascii-art

— Zukaberg
स्रोत

1

नमस्कार, और PPCG में आपका स्वागत है! आप इसे या इसके विपरीत बदलकर Increasingइसे थोड़ा सरल बनाना चाहते 1 => Inward, 0 => Outwardहैं।

— NoOneIsHere

1

@NoOneIsHere धन्यवाद! दिशा और अनुपात पार्सिंग लचीला है, नियम 3 के अनुसार, आप 0,1 का उपयोग दिशा को निर्दिष्ट करने के लिए कर सकते हैं या दोनों मापदंडों को एक में जोड़ सकते हैं, जैसे कि 4 आवक के लिए +4, 0.5 बाहर की ओर -0.5 आदि, इसे बस परिभाषित करने की आवश्यकता है समाधान के साथ।

— ज़ुकैबर्ग

3

यह एक बहुत ही रोचक चुनौती है! साइट पर आपका स्वागत है। :)

— DJMcMayhem

मैं यह नहीं देखता कि क्यों 2 के अंतर के अनुपात को बाहर की ओर बढ़ने के रूप में व्याख्या की जाती है, जबकि 1 और 0.5 दोनों अंदर की तरफ बढ़ते हैं।

— xnor

@xnor ओह भ्रम के लिए कोई खेद नहीं है, दिशा का अनुपात से कोई लेना-देना नहीं है, दिशा और अनुपात अलग-अलग पैरामीटर हैं, एक 2.0 आवक इस तरह C..O....D......E........G......O....L..F

— दिखेगी

3

जावास्क्रिप्ट (ईएस 6), 86 82 81 80 बाइट्स

इनपुट के f(s)(r)साथ सिंटेक्स में इनपुट की उम्मीद की जाती है :

s = तार
r = अनुपात + दिशा: आवक के लिए एक नकारात्मक फ्लोट या जावक के लिए एक सकारात्मक फ्लोट

let f =

s=>r=>s.replace(/./g,(c,i)=>c+' '.repeat(n+=i<l?-r:r),l=s.length/2,n=r>0&&l*r+r)

console.log(f("INTERSTELLAR")(-1));
console.log(f("INTERSTELLAR")(-0.5));
console.log(f("CODEGOLF")(2));
console.log(f("CODEGOLF")(0.4));

स्निपेट का विस्तार करें

— Arnauld
स्रोत

2

05AB1E , 33 बाइट्स

CP-1252 एन्कोडिंग का उपयोग करता है ।

गैप मल्टीप्लायर को बाहर की ओर बढ़ने पर नकारात्मक के रूप में लिया जाता है।

g;>Î.S<_²**ÄU¹vyð²¹g<;N.S*X+DUï×J

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

— Emigna
स्रोत

1

एपीएल, 40 बाइट्स

{⍵\⍨0~⍨∊1,⍨1,¨-⌊⍺×(1+⌈/-+)⍣⍺⍺(⌽⌊+)⍳⍴1↓⍵}

यह स्ट्रिंग को इसके सही तर्क के रूप में लेता है, इसके बाएं तर्क के रूप में अनुपात और इसके बाएं ऑपरेंड के रूप में दिशा (बाहरी के लिए 0 और बाहरी के लिए 1)।

      1 (0 {⍵\⍨0~⍨∊1,⍨1,¨-⌊⍺×(1+⌈/-+)⍣⍺⍺(⌽⌊+)⍳⍴1↓⍵}) 'INTERSTELLAR'
I N  T   E    R     S      T     E    L   L  A R
      0.5 (0 {⍵\⍨0~⍨∊1,⍨1,¨-⌊⍺×(1+⌈/-+)⍣⍺⍺(⌽⌊+)⍳⍴1↓⍵}) 'INTERSTELLAR'
IN T E  R  S   T  E  L L AR
      2 (1 {⍵\⍨0~⍨∊1,⍨1,¨-⌊⍺×(1+⌈/-+)⍣⍺⍺(⌽⌊+)⍳⍴1↓⍵}) 'CODEGOLF'
C        O      D    E  G    O      L        F
      0.4 (1 {⍵\⍨0~⍨∊1,⍨1,¨-⌊⍺×(1+⌈/-+)⍣⍺⍺(⌽⌊+)⍳⍴1↓⍵}) 'CODEGOLF'
C O DEGO L F

स्पष्टीकरण:

⍳⍴1↓⍵: 1 से N-1 तक की संख्या की सूची प्राप्त करें, जहां N स्ट्रिंग की लंबाई है
(⌽⌊+): सूची को उल्टा करें, और प्रत्येक स्थिति में, दोनों सूचियों की सबसे कम संख्या प्राप्त करें (यह अंदर की तरफ बढ़ने पर अंतराल का आकार देता है)
(1+⌈/-+)⍣⍺⍺: सूची में उच्चतम संख्या से सूची में प्रत्येक संख्या को घटाएं, और 1. इस ⍺⍺बार करें। (यदि ⍺⍺=0, कुछ भी नहीं होगा, और यदि ⍺⍺=1, यह बाहर की ओर बढ़ने पर अंतराल का आकार देगा।)
-⌊⍺×: प्रत्येक अंतर को गुणा करें ⍺, इसे नीचे की ओर गोल करें, और इसे नकारात्मक करें।
∊1,⍨1,¨: प्रत्येक अंतर के सामने एक 1 जोड़ें, और सूची के बहुत अंत में एक 1।
0~⍨: किसी भी शून्य को हटा दें।
⍵\⍨: विस्तार करने के लिए परिणामी सूची का उपयोग करें ⍵। विस्तार ( \) निम्नलिखित तरीके से काम करता है: प्रत्येक सकारात्मक संख्या के लिए, वर्तमान चरित्र को दोहराया जाता है कि कई बार, और प्रत्येक नकारात्मक संख्या के लिए, कि कई रिक्त स्थान डाले जाते हैं, कैविएट के साथ 0और ¯1वही काम करते हैं, यही कारण है कि सभी शून्य को पहले हटाया जाना था।

— मारीनस
स्रोत

1

MATL , 31 बाइट्स

nq:tPvX<i?tX>Qw-]*kQ1whYs''1Gb(

इनपुट्स हैं: स्ट्रिंग; 0या 1आवक या जावक वृद्धि के लिए; गुणक।

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

व्याख्या

आदानों पर विचार करें 'INTERSTELLAR', 1, 0.5एक उदाहरण के रूप।

nq:    % Input string implicitly. Push [1 2 ... N-1] where N is the string length
       %   STACK: [1 2 3 4 5 6 7 8 9 10 11]
tP     % Duplicate, reverse
       %   STACK: [1 2 3 4 5 6 7 8 9 10 11], [11 10 9 8 7 6 5 4 3 2 1]
vX<    % Vertically concatenate. Minimum of each column
       %   STACK: [1 2 3 4 5 6 5 4 3 2 1]
i      % Input direction flag
       %   STACK: [1 2 3 4 5 6 5 4 3 2 1], 1
?      % If input flag was 1 (meaning outward increasing)
  tX>  %   Duplicate. Maximum
       %     STACK: [1 2 3 4 5 6 5 4 3 2 1], 6
  Q    %   Add 1
       %     STACK: [1 2 3 4 5 6 5 4 3 2 1], 7
  w-   %   Swap. Subtract
       %     STACK: [6 5 4 3 2 1 2 3 4 5 6]
]      % End
*k     % Input multiplier implicitly. Multiply. Round down
       %   STACK: [3 2 2 1 1 0 1 1 2 2 3]
Q      % Add 1
       %   STACK: [4 3 3 2 2 1 2 2 3 3 4]
1wh    % Prepend a 1
       %   STACK: [1 4 3 3 2 2 1 2 2 3 3 4]
Ys     % Cumulative sum
       %   STACK: [1  5  8 11 13 15 16 18 20 23 26 30]
''     % Push empty string
       %   STACK: [1  5  8 11 13 15 16 18 20 23 26 30], ''
1G     % Push input string again
       %   STACK: [1  5  8 11 13 15 16 18 20 23 26 30], '', 'INTERSTELLAR'
b      % Bubble up
       %   STACK: '', 'INTERSTELLAR', [1  5  8 11 13 15 16 18 20 23 26 30]
(      % Assign the characters from the top string into the empty string at the 
       % given positions. Intermediate positions are filled with character 0, 
       % which is displayed as a space
       %   STACK: 'I   N  T  E R ST E L  L  A   R'
       % Dispaly implicitly

— लुइस मेंडो
स्रोत

1

रैकेट 348 बाइट्स

(define(f s)(let*((c #\space)(sp(λ(l)(define ol'())(for((i(length l)))(for((j i))
(set! ol(cons c ol)))(set! ol(cons(list-ref l i)ol)))(for((n(floor(/(length l)2))))
(set! ol(cons c ol)))ol))(m(floor(/(string-length s)2)))(s1(sp(string->list(substring s 0 m)
)))(s2(sp(reverse(string->list(substring s m))))))(list->string(append(reverse s1)s2))))

Ungolfed:

(define(f s)
  (let* ((c #\space)
         (sp (λ (l)           ; subfn to add increasing spaces to list of characters
               (define ol '())
               (for ((i (length l)))
                 (for ((j i))
                   (set! ol (cons c ol)))
                 (set! ol (cons (list-ref l i)ol)))
               (for ((n (floor(/ (length l)2)))) 
                 (set! ol (cons c ol)))
               ol))
         (m (floor (/ (string-length s) 2)))                 ; find midpoint
         (s1 (sp (string->list (substring s 0 m))))          ; add spaces to first part
         (s2 (sp (reverse (string->list (substring s m)))))) ; add spaces to second part
    (list->string (append (reverse s1) s2))                  ; re-combine 2 parts
    ))

परिक्षण:

(f "INTERSTELLAR")

आउटपुट:

"I N  T   E    R     S      T     E    L   L  A R"

— rnso
स्रोत

1

PHP, 129 बाइट्स

12 बिट्स @Titus धन्यवाद द्वारा बचाया

string = $ argv [1], अनुपात = $ argv [2], दिशा = $ argv [3] आवक = 0, जावक = 1

for($i=0;$i+1<2*$l=strlen($t=($x=$argv)[1]);)echo$i%2?str_pad("",$x[2]*abs($x[3]*(0^$l/2+1)-($i++>=$l?$l-$i/2:$i/2))):$t[$i++/2];

— जार्ग हुल्सरमैन
स्रोत

str_pad4 बाइट बचाना चाहिए। कोशिश करें ++$i>$l?$l-$i/2:$i/2और $t[$i++]/2लूप पोस्ट-कंडीशन में वेतन वृद्धि के बजाय; उसे बचाना चाहिए 9. क्यों 0^?

— टाइटस

@ टिट्स का 0^3.12परिणाम 3आवश्यक है

— जोर्ग ह्यूल्सरमैन

$i=0अनावश्यक है। ++$i>अभी भी एक बाइट को बचाता है $i++>=। और आप उस वृद्धि को पूर्व-स्थिति में ले जाकर एक और बाइट बचा सकते हैं: ++$i<2*$l=...इसके बजाय $i+1<2*$l=..., बाहरी टर्नरी की सच्ची और झूठी शाखाओं को स्वैप करें, $iइसके बजाय ++$iऔर के $t[$i/2-.5]बजाय $t[$i++/2]।

— टाइटस

अंदर 1और बाहर की तरह परिभाषित करना 2, आपको एक और 3 बाइट्स को बचाने में सक्षम करना चाहिए: ($l>>1)इसके बजाय (0^$l/2+1); लेकिन मैंने इनमें से किसी का भी परीक्षण नहीं किया।

— टाइटस

@ इस परिणाम में अधिक से अधिक रिक्त स्थान होंगे

— Jörg Hülsermann

मूवी शीर्षक स्टाइलिंग स्ट्रिंग

जावास्क्रिप्ट (ईएस 6), 86 82 81 80 बाइट्स

05AB1E , 33 बाइट्स

एपीएल, 40 बाइट्स

MATL , 31 बाइट्स

व्याख्या

रैकेट 348 बाइट्स

PHP, 129 बाइट्स