परिचय

इस उदाहरण के लिए, चलो स्ट्रिंग Hello, World!और एरे लेते हैं [3, 2, 3]। प्रतिस्थापन श्रृंखला को खोजने के लिए, हम निम्नलिखित प्रक्रिया से गुजरते हैं:

सरणी का पहला नंबर है 3, इसलिए हमें विकल्प मिलता है [0 - 3], जो है Hel। उसके बाद, हम 3शुरुआती स्ट्रिंग से पहले अक्षर हटाते हैं , जो हमें छोड़ देता है lo, World!।

सरणी की दूसरी संख्या है 2, इसलिए हम [0 - 2]अपने नए स्ट्रिंग से सबस्ट्रिंग प्राप्त करते हैं , जो हमें देता है lo। बचा हुआ तार बन जाता है , World!।

आखिरी नंबर एक है 3, जो हमें देता है , W। सबस्ट्रिंग श्रृंखला संयुक्त सबस्ट्रिंग है, जो हमें देता है के सभी प्रकार है:

['Hel', 'lo', ', W']

अधिक दृश्य उदाहरण के लिए:

[3, 2, 3], 'Hello, World!'
3 -> Hel
2 ->    lo
3 ->      , W

काम

एक गैर-रिक्त स्ट्रिंग और एक गैर-खाली सरणी को देखते हुए केवल सकारात्मक पूर्णांक ( > 0) से मिलकर , प्रतिस्थापन श्रृंखला को आउटपुट करता है । आप मान सकते हैं कि सरणी में सभी पूर्णांकों का योग स्ट्रिंग की लंबाई से अधिक नहीं है।

आप यह भी मान सकते हैं कि स्ट्रिंग्स में कभी कोई नयापन नहीं होगा।

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

Input: abcdefghijk, [2, 1, 3]
Output: ['ab', 'c', 'def']

Input: Code Golf, [4, 1]
Output: ['Code', ' ']

Input: Ayyy, [3]
Output: ['Ayy']

Input: lexicographically, [2, 2, 2, 7, 4]
Output: ['le', 'xi', 'co', 'graphic', 'ally']

यह कोड-गोल्फ है , इसलिए सबसे कम संख्या में बाइट्स जीतता है!

code-golf string

— अदनान
स्रोत

33

05AB1E , 1 बाइट

£

यह सबस्ट्रिंग (0, N) कमांड है।
एक सूची पर लागू यह स्ट्रिंग पर शेष पर बार-बार काम करता है।

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

— Emigna
स्रोत

9

उसे हरा नहीं सकते।

— स्टीवन एच।

12

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

s,a=input()
for n in a:print s[:n];s=s[n:]

कभी-कभी आप बस इसे उबाऊ तरीके से करते हैं।

— XNOR
स्रोत

अब तक बहुत सारे अजगर जवाबों में सबसे छोटा है

— साइओस

खैर जाहिरा तौर पर मैं इसे overthinking था, haha ...

— DJMcMayhem

8

ब्रेकीलॉग , 20 13 बाइट्स

h@[~c.:la~t?,

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

यह अंतिम परीक्षण के मामले में टीआईओ के लिए बेहद अक्षम और समय से बाहर है।

व्याख्या

Input = [String, List of integers]

h@[            Take a prefix of the string
   ~c.         Take a possible list of strings which when concatenated results in that prefix
      :la      Take the lengths of each element of that list
         ~t?,  This list of lengths is equal to the list of integers of the Input

थोड़ा और अधिक कुशल संस्करण, 15 बाइट्स

टी:।? {~ एल} एक, ज @ [~ ग

— Fatalize
स्रोत

8

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

f=lambda s,a:f(s[a[0]:print(s[:a.pop(0)])],a)

यह प्रिंट एक एक त्रुटि के साथ प्रत्येक पंक्ति में और समाप्त सबस्ट्रिंग जब एक शून्य हो जाता है।

यह repl.it पर परीक्षण करें ।

— डेनिस
स्रोत

2

क्या एक प्रिंट में चुपके के लिए एक शानदार तरीका है!

— xnor

7

पायथन, 52 , 46 बाइट्स

f=lambda a,s:a and[s[:a[0]]]+f(a[1:],s[a[0]:])

एक पुनरावर्ती लंबोदा समारोह।

6 बाइट्स से शेविंग करने के लिए डेनिस को धन्यवाद!

— DJMcMayhem
स्रोत

7

जेली , 6 बाइट्स

Jx$ĠịY

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

        The implicit working value is the first argument.
Jx$     Given a list L, repeat (x) an element of [1..len(n)] (J)
        as many times as the corresponding value in L.
   Ġ    Group indices by values. This turns [1, 1, 1, 2, 2, 3, 3]
        into [[1, 2, 3], [4, 5], [6, 7]].
    ị   Index into the second argument.
     Y  Join by newlines.

— लिन
स्रोत

5

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

s#(a:b)=take a s:drop a s#b
_#_=[]

उपयोग उदाहरण: "lexicographically" # [2,2,2,7,4]->["le","xi","co","graphic","ally"]

सरल पुनरावृत्ति।

या निर्मित के माध्यम से उबाऊ 29 बाइट्स समाधान:

import Data.Lists
splitPlaces

— nimi
स्रोत

5

रूबी, 26 बाइट्स

->w,a{a.map{|n|w.shift n}}

स्ट्रिंग को वर्णों के सरणियों के रूप में दर्शाया जाता है।

— एम-Chrzan
स्रोत

4

PowerShell v2 +, 46 बाइट्स

param($a,$b)$b|%{-join$a[$i..($i+=$_-1)];$i++}

इनपुट स्ट्रिंग $aऔर सरणी लेता है $b, लूप ओवर करता है $b। प्रत्येक पुनरावृत्ति, एक सरणी स्लाइस पर $aआधारित $i(डिफ़ॉल्ट $null, या 0) और वर्तमान संख्या के आधार पर करता है । करने की आवश्यकता है -1और $i++क्योंकि PowerShell में तार शून्य-अनुक्रमित हैं।

उदाहरण

(यहां आउटपुट स्पेस-सेपरेट है, क्योंकि एरे के लिए डिफॉल्ट स्ट्रिंगिफिकेशन मेथड है)

PS C:\Tools\Scripts\golfing> @('abcdefghijk',@(2,1,3)),@('Code Golf',@(4,1)),@('Ayyy',@(3)),@('lexicographically',@(2,2,2,7,4))|%{""+$_[0]+" -> "+(.\substring-chainification.ps1 $_[0] $_[1])}
abcdefghijk -> ab c def
Code Golf -> Code  
Ayyy -> Ayy
lexicographically -> le xi co graphic ally

— AdmBorkBork
स्रोत

4

पर्ल, 28 बाइट्स

के लिए +1 शामिल है -n

STDIN पर इनपुट स्ट्रिंग के साथ एक अलग लाइन पर प्रत्येक नंबर के साथ चलाएं:

(echo "Hello, World!"; echo 3; echo 2; echo 3) | perl -nE 'say for/(??{"."x<>||"^"})/g'

बस कोड:

say for/(??{"."x<>||"^"})/g

23 बाइट्स संस्करण ||"^"भी बिना किसी प्रकार के काम करता है, लेकिन नई अनुगामी अनुगामी प्रिंट करता है

"^"$_अगर स्ट्रिंग regex मेटा वर्ण शामिल नहीं है द्वारा प्रतिस्थापित किया जा सकता है

— टन हास्पेल
स्रोत

3

MATL , 8 बाइट्स

ys:)1bY{

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

व्याख्या

y    % Implicitly take the two inputs: numerical array, string. Duplicate the array
s    % Sum of the array, say n
:    % Range from 1 to n
)    % Take first n characters of the string
1    % Push 1
b    % Bubble up the original copy of the string to the top
Y{   % Split into pieces of lengths given by the numerical array. The pieces are 
     % stored in a cell array, which is implicitly displayed, one cell per line

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

3

जावास्क्रिप्ट (ईएस 6), 39 38 35 बाइट्स

सहेजे गए 3 बाइट्स ETHproductions के लिए धन्यवाद:

s=>a=>a.map(v=>s.slice(t,t+=v),t=0)

उदाहरण:

//Definition
f=
s=>a=>a.map(v=>s.slice(t,t+=v),t=0)

//Call
f('lexicographically')([2, 2, 2, 7, 4]);

//Output
Array [ "le", "xi", "co", "graphic", "ally" ]

पिछला समाधान:
हंट्रो के लिए 38 बाइट्स धन्यवाद:

s=>a=>a.map(v=>s.substr(t,v,t+=v),t=0)

39 बाइट्स:

(s,a)=>a.map(v=>s.substr(t,v,t+=v),t=0)

— Hedi
स्रोत

1

आप एक बाइट को करीने से बचा सकते हैं

— हंट्रो

2

.sliceकुछ बाइट्स बचाता है:s=>a=>a.map(v=>s.slice(t,t+=v),t=0)

— ETHproductions

3

बैच, 74 बाइट्स

@set/ps=
@for %%i in (%*)do @call echo %%s:~0,%%i%%&call set s=%%s:~%%i%%

मैं सी मार रहा हूँ? यह सही नहीं हो सकता! STDIN पर स्ट्रिंग लेता है और कमांड लाइन तर्क के रूप में सरणी।

— नील
स्रोत

3

जावा, 119 बाइट्स

String[] substringChainification(String s, int[] i) {
    String[] r = new String[i.length];
    int j = 0, f = 0;
    for (int t : i)
        r[j++] = s.substring(f, f += t);
    return r;
}

golfed:

String[]s(String s,int[]i){String[]r=new String[i.length];int j=0,f=0;for(int t:i)r[j++]=s.substring(f,f+=t);return r;}

मैंने रोमन ग्रैफ़ के उत्तर ( /codegolf//a/93992/59935 ) को संशोधित किया है , लेकिन मेरे पास टिप्पणी करने के लिए पर्याप्त प्रतिनिधि नहीं है।

मैंने लूप कार्यान्वयन को बदल दिया और स्रोत स्ट्रिंग को प्रत्येक पुनरावृत्ति में किसी अन्य सबस्ट्रिंग में सेट करने के बजाय, मैं सिर्फ उन सूचकांकों को बदलता हूं जिनके साथ मैं प्रतिस्थापन प्राप्त करता हूं।

— mrco
स्रोत

2

PPCG में आपका स्वागत है! महान पहली पोस्ट! यह वही है जो आपको एक गोल्फ सुझाव के साथ करना चाहिए, लेकिन पर्याप्त प्रतिनिधि नहीं।

— R

1

PPCG में आपका स्वागत है! और मैं _EasterlyIrk_ , महान पहली पोस्ट से सहमत हूं । मैंने गोल्फ को कुछ खोजने की कोशिश की, लेकिन नहीं कर पाया। हो सकता है कि आपने इसे पहले ही देख लिया हो, लेकिन आपको पढ़ने में दिलचस्प जावा में गोल्फिंग के लिए टिप्स मिल सकते हैं। एक बार फिर से स्वागत है, और अपने प्रवास का आनंद लें।

— केविन क्रूजेसेन

2

पाइके, 10 बाइट्स

FQR<
Ki?>Q

यहाँ कोशिश करो!

— नीला
स्रोत

2

sed (82 + 2 for -rn) 84

s,^,\n,;:l;N;s,\n\n,\n,;:
s,^([^\n]*)\n(.)([^\n]*\n)1,\1\2\n\3,
t;P;s,^[^\n]*,,;tl

इनपुट की पहली पंक्ति स्ट्रिंग है। फिर इसके बाद प्रत्येक पंक्ति में सबस्ट्रिंग के आकार है एकल ।

उदाहरण:

$ cat test.txt:
lexicographically
11
11
11
1111111
1111

$ cat hold | sed -rnf sed.txt
le
xi
co
graphic
ally

— रिले
स्रोत

2

सीजेएम , 11 बाइट्स

lq~{/(ns}/;

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

व्याख्या

l    e# Read input string.
q~   e# Read array of lengths and eval.
{    e# For each length...
  /  e#   Split the string into chunks of the given size.
  (  e#   Pull off the first chunk.
  n  e#   Print with linefeed.
  s  e#   Flatten the remaining chunks into a single string again.
}/
;    e# Discard any remainder of the input string.

— मार्टिन एंडर
स्रोत

2

सी, 81 बाइट्स

i,j;f(s,l,k)char*s;int*l;{for(i=j=0;i<k;){write(1,s+j,l[i]);puts("");j+=l[i++];}}

क्योंकि write()आउटपुट किसी भी ऑनलाइन संकलक को बफ़र नहीं कर रहा है, इसलिए इसे आउटपुट करने में कठिन समय होगा।

test.c :

i,j;f(s,l,k)char*s;int*l;{for(i=j=0;i<k;){write(1,s+j,l[i]);puts("");j+=l[i++];}}
main(){
    int l[]={3,2,3};
    f("Hello, World!",l,3);
    int ll[]={2,1,3};
    f("abcdefghijk",ll,3);
    int lll[]={4,1};
    f("Code Golf",lll,2);
    int llll[]={3};
    f("Ayyy",llll,1);
    int lllll[]={2,2,2,7,4};
    f("lexicographically",lllll,5);
}

पाइपिंग के बिना आउटपुट:

Hel
lo
, W
ab
c
def
Code

Ayy
le
xi
co
graphic
ally

— betseg
स्रोत

उपरोक्त सी प्रोग्राम के आइडोन कंपाइलर l'output में [स्क्रीन में पहले फंक्शन को और हाईट को कॉपी करते हुए] "हेलो, वबकडेफोड आयोडिकोग्राफिक रूप से" बिना "\ n" है ...

— RosLuite

2

PHP, 98 बाइट्स

<?php
$b=$argv[1];foreach(explode(',',$argv[2])as$a){echo(substr($b,0,$a).' ');$b=substr($b,$a);}

उपयोग:

php chainification.php lexicographically 2,2,2,7,4

आउटपुट:

le xi co graphic ally

शायद PHP के साथ एक बेहतर समाधान है।

— jrenk
स्रोत

2

PHP, 82 बाइट्स

<?php for($s=$argv[++$i],$j=-1;$n=$argv[++$i];){for(;$n--;)echo$s[++$j];echo"
";}

इनपुट को एक स्ट्रिंग के रूप में लेता है और फिर संख्याओं की सूची, आउटपुट को नई लाइनों द्वारा अलग किया जाता है। जैसे

php chainify.php lexicographically 2 2 2 7 4

यदि आप उन लोगों में से हैं, जो $ argv का उपयोग करने में सक्षम हैं, तो आप उद्घाटन टैग के लिए उपयोग किए जाने वाले 6 बाइट्स को बचा सकते हैं।

— user59178
स्रोत

के उपयोग को लेकर मैं भ्रमित हूं $argv[++$i]। क्यों $argv[1]और $argv[2]क्या नहीं ?

— मंकीज़े

इसके अलावा, sandbox.onlinephpfunctions.com पर PHP 7.0.2 का उपयोग करके मैंने 3 सेकंड की समय-सीमा

— मंकीज़ सिप

ऐसा $argv[2]इसलिए नहीं है क्योंकि हमें बड़े पैमाने पर तर्कों के माध्यम से पुनरावृति करने की आवश्यकता है और $argv[++$i]पहली बार ,$i=12 बाइट्स की आवश्यकता से बचने के लिए यह आवश्यक है ।

— user59178

2

PHP, 63 बाइट्स

<?foreach($_GET[a]as$p){echo" ".substr($_GET[s],$s,$p);$s+=$p;}

85 बाइट्स के रूप में आउटपुट

<?foreach($_GET["a"]as$p){$o[]=substr($_GET["s"],$s,$p);$s+=$p;}echo json_encode($o);

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

1

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

PcwsM._

न्यूलाइन द्वारा अलग किए गए इनपुट को ले जाता है, स्ट्रिंग के साथ अनुपस्थित और सरणी के बाद आता है। इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

     ._  Get all prefixes of Q
   sM    Map sum across each of these prefixes (to get the total indices)
 cw      Split the string at these locations
P        Remove the last "remainder" of the string

— स्टीवन एच।
स्रोत

1

ऑक्टेव / MATLAB, 31 बाइट्स

@(s,a)mat2cell(s(1:sum(a)),1,a)

यह इनपुट के साथ एक अनाम फ़ंक्शन है s: स्ट्रिंग; a: संख्यात्मक सरणी।

Ideone में यह कोशिश करो ।

व्याख्या

यह मेरे MATL उत्तर का एक पोर्ट है।

s(1:sum(a))        % Take first n characters of string s, where n is the sum of array a
mat2cell(...,1,a)  % Split into pieces of lengths given by a and store in a cell array

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

1

जावा 142 बाइट्स

public static String[]substringChain(String s,int[]i){
  String[]r=new String[i.length];
  for(int j=-1;++j<i.length;){
    r[j]=s.substring(0,i[j]);
    s=s.substring(i[j]);
  }
  return b;
}

golfed:

String[]s(String s,int[]i){String[]r=new String[i.length];for(int j=-1;++j<i.length;){r[j]=s.substring(0,i[j]);s=s.substring(i[j]);}return b;}

— रोमन ग्रैफ़
स्रोत

1

अवाक, 36 वर्ण

{FIELDWIDTHS=$0;OFS=RS;getline}$1=$1

नमूना रन:

bash-4.3$ awk '{FIELDWIDTHS=$0;OFS=RS;getline}$1=$1' <<< $'3 2 3\nHello, World!'
Hel
lo
, W

वास्तविक जीवन में मैं इसका उपयोग इस तरह से करूंगा, बस इसके स्कोर की गणना करने का कोई विचार नहीं है:

bash-4.3$ awk -vFIELDWIDTHS='3 2 3' -vOFS='\n' '$1=$1' <<< 'Hello, World!'
Hel
lo
, W

— आदमी काम पर है
स्रोत

1

डायलॉग एपीएल 16.0, 15 अक्षर (गैर-प्रतिस्पर्धात्मक); 15.0, 17 बाइट्स

16.0 समाधान

{⍵⊆⍨(⍴⍵)↑⍺/+\⍺}

Dyalog APL 16.0 ग्लाइफ के साथ APL2 के विभाजन को आदिम जोड़ता है ।⊂⊆

15.0 समाधान:

{(-⍺)↑¨(+\⍺)↑¨⊂⍵}

TryAPL ऑनलाइन!

— एडम
स्रोत

1

GNU सेड, 55 + 2 (आरएन झंडे) = 57 बाइट्स

1H;1d;G;:;s=.(\n.*)\n(.)=\1\2\n=;t;s=.==;P;s=[^\n]*==;h

इसे ऑनलाइन आज़माएं! (sed जोड़ने के लिए @ डेनिस का धन्यवाद)

स्पष्टीकरण: इनपुट स्ट्रिंग पहली पंक्ति और संख्याओं पर होनी चाहिए, एकतरफा में , उसके बाद अलग-अलग लाइनों पर। हर बार स्क्रिप्ट को चलाने के लिए एक नई लाइन को चक्र की शुरुआत में पढ़ा जाता है।

1H;1d                       # once: append string to hold space and start new cycle
                            #Initially, the hold space contains an useful '\n'.
G                           # append hold space to pattern space. The pattern space
                            #format will be: 'UNARY\n\nSTRING'.
:;s=.(\n.*)\n(.)=\1\2\n=;t  # iteratively remove a char from the string, as many
                            #times as unary chars, and store it on 2nd pattern line
s=.==;P                     # remove '\n', then print the new top line
s=[^\n]*==;h                # delete up to '\n' and update hold space

टेस्ट रन: अंतिम मार्कर के रूप में ईओएफ के साथ यहां दस्तावेज़ का उपयोग करना

sed -rnf program.sed << EOF
> abcdefghijk
> 00
> 0
> 000
> EOF

आउटपुट:

ab
c
def

— seshoumara
स्रोत

1

विम्सस्क्रिप्ट, 79 78 बाइट्स

बहुत सुंदर नहीं, मुझे यकीन है कि इसमें सुधार किया जा सकता है ...

विम बफर लेता है, फिर echom string(A([2,3]))आउटपुट देखने के लिए कॉल करता है

fu A(l)
let r=[]
for i in a:l
exe "norm d".i."l"
let r+=[@"]
endfo
retu r
endf

मैंने वास्तव में धोखा देने और स्ट्रिंग को आउटपुट करने के बारे में सोचा था ["abc", "def"]... लेकिन मैंने विरोध किया: पी

स्पष्टीकरण: हटाएं (डिफ़ॉल्ट रजिस्टर में डालता है) प्रत्येक सरणी वर्णों की मात्रा को मापता है और इसे सरणी में जोड़ता है r... वास्तव में एक उबाऊ उत्तर।

— क्रिश्चियन रोंडेउ
स्रोत

1

आम लिस्प, 78 76 बाइट्स

अनाम फ़ंक्शन मानने की अनुमति है:

(lambda(s l)(loop for x in l as y = x then(+ y x)collect(subseq s(- y x)y)))

प्रयोग

(funcall #'(lambda(s l)(loop for x in l as y = x then(+ y x)collect(subseq s(- y x)y)))"AbCdefGhijK"'(3 2 3))

उत्पादन

("AbC" "de" "fGh")

में दो चर के बीच कोष्ठक फिट करने के लिए y परिभाषा को बदलने और बदलने के asबजाय का उपयोग करके -2 बाइट्सand(subseq ...)

1

रीबोल, 38 बाइट्स

func[s b][map-each n b[take/part s n]]

— draegtun
स्रोत

पदार्थ का चैन

परिचय

काम

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

05AB1E , 1 बाइट

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

ब्रेकीलॉग , 20 13 बाइट्स

व्याख्या

थोड़ा और अधिक कुशल संस्करण, 15 बाइट्स

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

पायथन, 52 , 46 बाइट्स

जेली , 6 बाइट्स

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

रूबी, 26 बाइट्स

PowerShell v2 +, 46 बाइट्स

उदाहरण

पर्ल, 28 बाइट्स

MATL , 8 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 6), 39 38 35 बाइट्स

बैच, 74 बाइट्स

जावा, 119 बाइट्स

पाइके, 10 बाइट्स

sed (82 + 2 for -rn) 84

सीजेएम , 11 बाइट्स

व्याख्या

सी, 81 बाइट्स

PHP, 98 बाइट्स

PHP, 82 बाइट्स

PHP, 63 बाइट्स

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

ऑक्टेव / MATLAB, 31 बाइट्स

व्याख्या

जावा 142 बाइट्स

अवाक, 36 वर्ण

डायलॉग एपीएल 16.0, 15 अक्षर (गैर-प्रतिस्पर्धात्मक); 15.0, 17 बाइट्स

16.0 समाधान

15.0 समाधान:

GNU सेड, 55 + 2 (आरएन झंडे) = 57 बाइट्स

विम्सस्क्रिप्ट, 79 78 बाइट्स

आम लिस्प, 78 76 बाइट्स

प्रयोग

उत्पादन

रीबोल, 38 बाइट्स