Chaînification de la sous-chaîne

27

introduction

Pour cet exemple, prenons la chaîne Hello, World!et le tableau [3, 2, 3]. Pour trouver la chaîne de sous-chaîne, nous passons par le processus suivant:

Le premier nombre du tableau est 3, donc nous obtenons la sous-chaîne [0 - 3], qui est Hel. Après cela, nous supprimons les premiers 3caractères de la chaîne initiale, ce qui nous laisse lo, World!.

Le deuxième nombre du tableau est 2, donc nous obtenons la sous-chaîne [0 - 2]de notre nouvelle chaîne, ce qui nous donne lo. La chaîne restante devient , World!.

Le dernier chiffre est un 3, ce qui nous donne , W. La chaîne de sous-chaîne est l'ensemble des sous-chaînes combinées, ce qui nous donne:

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

Pour un exemple plus visuel:

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

La tâche

Étant donné une chaîne non vide et un tableau non vide composé uniquement d' entiers positifs ( > 0), affichez la chaîne de sous-chaîne . Vous pouvez supposer que la somme de tous les entiers du tableau ne dépasse pas la longueur de la chaîne.

Vous pouvez également supposer que les chaînes ne contiendront jamais de nouvelles lignes.

Cas de test

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

C'est du code-golf , donc la soumission avec le plus petit nombre d'octets gagne!

code-golf  string 
— Adnan
source

Réponses:

12

Python 2, 42 octets

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

Parfois, vous le faites simplement d'une manière ennuyeuse.

— xnor
source
Jusqu'à présent, la réponse la plus courte de beaucoup trop de python
— Cyoce
Eh bien apparemment, j'y pensais trop, haha ​​...
— DJMcMayhem
8

Brachylog , 20 13 octets

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

Essayez-le en ligne!

Ceci est extrêmement inefficace et expire sur TIO pour le dernier cas de test.

Explication

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

Une version légèrement plus efficace, 15 octets

t: {~ l} a.,? h @ [~ c

— Fatalize
source
8

Python 3, 45 octets

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

Cette imprime une ligne par sous - chaîne et se termine par une erreur lors d' une est épuisé.

Testez - le sur repl.it .

— Dennis
source
2
Quelle belle façon de se faufiler dans une impression!
— xnor
7

Python, 52 , 46 octets

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

Une fonction lambda récursive.

Merci à Dennis d'avoir rasé 6 octets!

— DJMcMayhem
source
7

Gelée , 6 octets

Jx$ĠịY

Essayez-le en ligne!

        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.
— Lynn
source
5

Haskell, 34 octets

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

Exemple d'utilisation: "lexicographically" # [2,2,2,7,4]->["le","xi","co","graphic","ally"]

Récursivité simple.

Ou la solution ennuyeuse de 29 octets via intégrée:

import Data.Lists
splitPlaces
— nimi
source
5

Rubis, 26 octets

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

Les chaînes sont représentées sous forme de tableaux de caractères.

— m-chrzan
source
4

PowerShell v2 +, 46 octets

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

Prend la chaîne $aet le tableau d' entrée $b, boucle $b. Chaque itération effectue une tranche de tableau en $afonction de $i(par défaut $null, ou 0) et du nombre actuel. Doit faire le -1et$i++ car les chaînes dans PowerShell sont indexées à zéro.

Exemples

(La sortie ici est séparée par des espaces, car c'est la méthode de stringification par défaut pour les tableaux)

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
source
4

Perl, 28 octets

Comprend +1 pour -n

Exécutez avec la chaîne d'entrée sur STDIN suivie de chaque numéro sur une ligne distincte:

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

Juste le code:

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

La version de 23 octets sans ||"^"aussi sorte de travaux, mais imprime de nouvelles lignes de queue parasites

"^"peut être remplacé par $_si la chaîne ne contient pas de méta caractères regex

— Ton Hospel
source
3

MATL , 8 octets

ys:)1bY{

Essayez-le en ligne!

Explication

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
— Luis Mendo
source
3

JavaScript (ES6), 39 38 35 octets

Sauvegardé 3 octets grâce à ETHproductions:

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

Exemple: 

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

Solution précédente:
38 octets grâce à Huntro:

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

39 octets:

(s,a)=>a.map(v=>s.substr(t,v,t+=v),t=0)
— Hedi
source
1
Vous pouvez enregistrer un octet en curry
— Huntro
2
.sliceenregistre quelques octets:s=>a=>a.map(v=>s.slice(t,t+=v),t=0)
— ETHproductions
3

Lot, 74 octets

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

Je bat C? Ça ne peut pas être vrai! Prend la chaîne sur STDIN et le tableau comme arguments de ligne de commande.

— Neil
source
3

Java, 119 octets

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;
}

Golfé:

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;}

J'ai modifié la réponse de Roman Gräf ( /codegolf//a/93992/59935 ), mais je n'ai pas assez de représentant pour commenter.

J'ai changé l'implémentation de la boucle et au lieu de définir la chaîne source sur une autre sous-chaîne à chaque itération, je change simplement les indices avec lesquels j'obtiens la sous-chaîne.

— mrco
source
2
Bienvenue chez PPCG! Excellent premier post! C'est exactement ce que vous devez faire avec une suggestion de golf, mais pas assez de répétition.
— Rɪᴋᴇʀ
1
Bienvenue chez PPCG! Et je suis d'accord avec _EasterlyIrk_ , excellent premier post. J'ai essayé de trouver plus pour jouer au golf, mais je n'ai pas réussi. Vous l'avez peut-être déjà vu, mais vous trouverez peut-être des conseils pour jouer au golf à Java intéressants. Encore une fois, bienvenue et profitez de votre séjour.
— Kevin Cruijssen
2

sed (82 + 2 pour -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

La première ligne d'entrée est la chaîne. Ensuite, chaque ligne après cela est la taille d'une sous-chaîne unaire .

Exemple:

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

$ cat hold | sed -rnf sed.txt
le
xi
co
graphic
ally
— Riley
source
2

CJam , 11 octets

lq~{/(ns}/;

Essayez-le en ligne!

Explication

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.
— Martin Ender
source
2

C, 81 octets

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++];}}

Parce que la write()sortie n'est pas mise en mémoire tampon, tout compilateur en ligne aura du mal à sortir cela.

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);
}

Sortie sans tuyauterie:

Hel
lo
, W
ab
c
def
Code

Ayy
le
xi
co
graphic
ally
— betseg
source
dans le compilateur ideone la sortie du programme c ci-dessus [copiant la première fonction la plus élevée dans l'écran] est "Bonjour, WabcdefCode Ayylexicographically" sans "\ n" ...
— RosLuP
2

PHP, 98 octets

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

Usage: 

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


Sortie: 

le xi co graphic ally


Il y a probablement une meilleure solution avec PHP.

— jrenk
source
2

PHP, 82 octets

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

Prend l'entrée sous forme de chaîne, puis une liste de nombres, la sortie est séparée par de nouvelles lignes. par exemple

php chainify.php lexicographically 2 2 2 7 4

Si vous faites partie de ces personnes capables d'utiliser $ argv avec -r, vous pouvez enregistrer les 6 octets utilisés pour la balise d'ouverture.

— user59178
source
Je suis confus quant à l'utilisation de $argv[++$i]. Pourquoi pas $argv[1]et $argv[2]?
— MonkeyZeus
De plus, en utilisant PHP 7.0.2 sur sandbox.onlinephpfunctions.com, j'ai atteint le délai de 3 secondes
— MonkeyZeus
ce n'est pas $argv[2]parce que nous devons parcourir les arguments supprimés et c'est $argv[++$i]la première fois pour éviter le besoin d'un ,$i=1et donc économiser 2 octets.
— user59178
2

PHP, 63 octets

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

Sortie sous forme de tableau 85 octets

<?foreach($_GET["a"]as$p){$o[]=substr($_GET["s"],$s,$p);$s+=$p;}echo json_encode($o);
— Jörg Hülsermann
source
1

Pyth, 7 octets

PcwsM._

Prend les entrées séparées par un retour à la ligne, avec la chaîne non échappée et venant après le tableau. Essayez-le en ligne!

Explication:

     ._  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
— Steven H.
source
1

Octave / MATLAB, 31 octets

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

Il s'agit d'une fonction anonyme avec des entrées s: chaîne; a: tableau numérique.

Essayez-le chez Ideone .

Explication

Ceci est un portage de ma réponse 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
— Luis Mendo
source
1

Java 142 octets

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;
}

Golfé:

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;}
— Roman Gräf
source
1

Awk, 36 caractères

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

Exemple d'exécution:

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

Dans la vraie vie, je l'utiliserais comme ça, juste aucune idée de comment calculer son score:

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

GNU sed, 55 + 2 (drapeaux rn) = 57 octets

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

Essayez-le en ligne! (merci à @Dennis d'avoir ajouté sed)

Explication: La chaîne d'entrée doit être sur la première ligne et les nombres, en unaire , sur des lignes distinctes après cela. Une nouvelle ligne est lue implicitement au début d'un cycle, exécutant le script à chaque fois.

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

Test: utilisation d'un document ici avec EOF comme marqueur de fin

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

Sortie:

ab
c
def
— seshoumara
source
1

Vimscript, 79 78 octets

pas très joli, je suis sûr qu'il peut être amélioré ...

Prend un tampon vim, puis appelle echom string(A([2,3]))pour voir la sortie

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

J'ai pensé à tricher et à sortir la chaîne ["abc", "def"] ... Mais j'ai résisté: P

Explication: Supprimez (place dans le registre par défaut) chaque tableau des éléments des quantités de caractères et l'ajoute au tableau r... Une réponse ennuyeuse en effet.

— Christian Rondeau
source
1

Lisp commun, 78 76 octets

En supposant que la fonction anonyme est autorisée:

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

Usage

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

Sortie

("AbC" "de" "fGh")

-2 octets en utilisant asau lieu de andet en changeant la définition de y pour ajuster les parenthèses entre deux variables dans(subseq ...)

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.