Art ASCII aligné horizontalement

20

Votre tâche consiste à accepter comme entrée deux "Art ASCII" et à aligner chaque œuvre d'art côte à côte horizontalement.

Par exemple, supposons que vous ayez deux chaînes "abc\ndef"et "123\n456". Vous devez les aligner horizontalement pour produire la chaîne "abc123\ndef456". J'appelle cela" aligner horizontalement "car pendant que les entrées, une fois imprimées, ressemblent à ceci:

abc
def

et:

123
456

La sortie, une fois imprimée, ressemblera à ceci:

abc123
def456

Notez comment une entrée est placée à côté de l'autre.

Contribution

  • L'entrée sera des chaînes et peut être sous la forme de deux arguments distincts ou sous la forme d'une séquence de chaînes.
  • Les caractères dans les arts auront des codes décimaux compris entre 32 et 126 (inclus).
  • C'est bien de prendre en charge un nombre arbitraire d'arts à aligner au lieu de deux (mais vous devez évidemment en prendre au moins deux).
  • Vous pouvez supposer que chaque art aura les mêmes dimensions et qu'elles contiendront au moins une ligne.

  • Vous devez être capable de supporter au moins 100x100 arts des personnages.

  • Pour s'aligner sur les conventions du site, l'ordre des arguments n'a pas d'importance. Peu importe quel art est à gauche ou à droite.

Production

  • La sortie sera les arts alignés comme mentionné ci-dessus, soit retournés soit sortis vers la sortie standard.

  • Tout espace de fin en option.

  • Il ne doit pas y avoir de séparateur visuel entre les arts alignés.

Les arts d'entrée et de sortie doivent être \nou\r chaînes délimitées. Il serait trop trivial d'autoriser les tableaux 2D.

Les soumissions peuvent être des fonctions ou des programmes complets.

Cas de test:

"abc\ndef", "123\n456" -> "abc123\ndef456".

"qwertyuiop\n asdfghjkl", "Some other\nTextFiller" -> "qwertyuiopSome other\n asdfghjklTextFiller"

"  *  \n *** \n*****\n *** \n  *  \n", "  +  \n  +  \n+++++\n  +  \n  +  \n" -> "  *    +  \n ***   +  \n*****+++++\n ***   +  \n  *    +  \n"
code-golf  ascii-art 
— Carcigenicate
source
1
Pouvons-nous utiliser un délimiteur personnalisé au lieu de nouvelles lignes? c'est à dire "|"ou " "?
— Rɪᴋᴇʀ
10
Je vais dire non, car cela ruinerait un art.
— Carcigenicate
Pouvons-nous utiliser à la \rplace de \n?
— Adám
@ Adám Sûr. Je mettrai à jour le libellé.
— Carcigenicate
Le premier espace blanc est-il correct?
— Adám

Réponses:

20

Toile , 1 octet

×

Essayez-le ici!

— dzaima
source
6
Car qui n'a pas seulement une fonction intégrée pour ça? : P
— caird coinheringaahing
5
Ce n'est même pas juste. ; -;
— 2018 totalement humain
3
@KevinCruijssen Sur PPCG, il est généralement autorisé de prendre des entrées dans l'ordre que vous souhaitez, et pour un langage basé sur la pile, l'ordre actuel est plus logique que inverse.
— dzaima
5
@KevinCruijssen bien que je me souvienne juste que j'ai une fonction intégrée pour le reverse add, donc je mets à jour le message: p
— dzaima
2
Donc, Canvas a deux fonctions intégrées pour cela? OK pourquoi pas?
— caird coinheringaahing
6

Python 2 , 59 octets

lambda y:'\n'.join(map(str.__add__,*map(str.splitlines,y)))

Essayez-le en ligne!

— Rɪᴋᴇʀ
source
Il peut également être raccourci en supprimant l'espace. : P
— totalement humain
Si vous voulez entrer et sortir des listes de lignes, comme vous l'aviez auparavant, vous pouvez le faire descendre à 30: Essayez-le en ligne!
Je suis resté là pendant environ 5 minutes à essayer de décider si je devais autoriser cela. Comme le montre la réponse de Haskell, cela réduirait le défi à quelque chose de beaucoup plus trivial. Je suppose cependant que les solutions trop triviales ne seraient tout simplement pas aussi populaires.
— Carcigenicate
4

05AB1E , 6 octets

|¶¡øJ»

Essayez-le en ligne!

Explication

|        # push all input into a list
 ¶¡      # split on newlines
   ø     # zip
    J    # join the rows to single strings
     »   # merge on newlines
— Emigna
source
Dommage qu'un espace entre les deux entrées ne soit pas autorisé :(.
— Urne Magic Octopus
3

Perl 5 -0F , 28 octets

Comprend +2pour l' \nargument-F (c'est "code" donc ça devrait compter)

Donnez des entrées directement après l'autre sur STDIN.

#!/usr/bin/perl -0F\n
say@F[$%++,$_]for@F/2..$#F

Essayez-le en ligne!

— Ton Hospel
source
3

Bash + coreutils, 14

  • 4 octets enregistrés grâce à @DavidFoerster.
paste -d "" $@

L'entrée est donnée sous deux noms de fichiers en tant que paramètres de ligne de commande.

Essayez-le en ligne .

— Traumatisme numérique
source
Vous pouvez enregistrer 4 octets:paste -d "" $@
— David Foerster
@DavidFoerster Merci! Bizarre - j'ai essayé ça plus tôt et ça n'a pas marché. Edit - je vois maintenant - au lieu de -d "", j'ai essayé -d"", ce qui bien sûr n'est pas différent de-d
— Digital Trauma
2

APL (Dyalog Unicode) , 9 octets SBCS

Programme complet. Invite (STDIN) pour toute liste de longueur de \rchaînes délimitées. Les chaînes peuvent être irrégulières et de largeurs différentes tant qu'elles ont le même nombre de lignes. Imprime (STDOUT) résultant de l'art ASCII.

⊃,/⎕FMT¨⎕

Essayez-le en ligne!

⎕ invite pour l'entrée évaluée

⎕FMT¨ format (évaluer tous les caractères de contrôle et retourner la matrice de caractères) chacun

,/ les combiner horizontalement (réduction de caténation)

⊃ divulguer (car la réduction a réduit le rang de 1 à 0)

— Adam
source
2

Java 8, 100 84 78 octets

a->b->{for(int i=0;;)System.out.println(a.split("\n")[i]+b.split("\n")[i++]);}

Quitte avec un ArrayIndexOutOfBoundsExceptionvers STDERR après avoir imprimé le résultat dans STDOUT, ce qui est autorisé .

-6 octets grâce à @ OlivierGrégoire .

Explication:

Essayez-le en ligne.

a->b->{                        // Method with two String parameters and no return-type
  for(int i=0;;)               //  Loop over the substrings of the first input
    System.out.println(        //   Print:
     a.split("\n")[i]          //    The substring of the first input
     +b.split("\n")[i++]);}    //    plus the same-indexed substring of the second input
— Kevin Cruijssen
source
1
a->b->{for(int i=0;;)System.out.println(a.split("\n")[i]+b.split("\n")[i++]);}78 octets. Rien n'est dit sur l'absence d'effets secondaires supplémentaires. Nous pourrions donc simplement compter jusqu'à ce qu'une exception se produise.
— Olivier Grégoire
@ OlivierGrégoire Merci! Et sortir avec une erreur vers STDERR est en effet autorisé après qu'il a tout imprimé sur STDOUT.
— Kevin Cruijssen
2

Rubis , 48 octets

->a,b{$;=$/;a.split.zip(b.split).map(&:join)*$/}

Essayez-le en ligne!

Un lambda prenant deux chaînes et renvoyant une chaîne. La définition du splitdélimiteur par défaut sur la nouvelle ligne avec $;=$/;ne sauvegarde aucun octet, mais rend le reste un peu plus agréable.

Ruby , 49 octets (arbitrairement plusieurs chaînes)

->s{s.map{|a|a.split$/}.transpose.map(&:join)*$/}

Essayez-le en ligne!

Juste pour le fun. Il s'avère que nous pouvons accepter un tableau de chaînes à un coût supplémentaire de seulement 1 octet.

— benj2240
source
2

JavaScript (ES6), 51 octets

f=
(a,b)=>a.replace(/.+/g,a=>a+b.shift(),b=b.split`
`)
;document.write("<pre>"+f("abc\ndef", "123\n456")+"</pre>")
Développer l'extrait

— Neil
source
2

Merveille , 21 octets

->#oN.zip#++.-> <>"
"

Exemple d'utilisation:

(->#oN.zip#++.-> <>"
")["abc#ndef" "abc#ndef"]

#nest utilisé au lieu de \npour désigner les nouvelles lignes.

Explication

Version détaillée:

(map #oN) . (zip #con) . (map split "#n")

Divisez chaque chaîne dans le tableau d'entrée le long des sauts de ligne, zippez avec la chaîne concaténée et sortez chaque élément.

— Mama Fun Roll
source
1

JavaScript (ES6), 52 octets

Prend une entrée dans la syntaxe de curry (a)(b).

a=>b=>a.split`
`.map((s,i)=>s+b.split`
`[i]).join`
`

Essayez-le en ligne!

— Arnauld
source
1

PowerShell , 51 49 octets

param($a,$b)$a-split"
"|%{$_+($b-split"
")[$i++]}

Essayez-le en ligne!

Prend l'entrée sous forme de chaînes littérales avec des retours à la ligne. Vous pouvez également utiliser `n(le délimiteur de nouvelle ligne dans PowerShell, non \n) à la place.

Nous commençons par -splitla chaîne d'entrée gauche sur les sauts de ligne, ce qui crée un tableau, et bouclons à travers cela |%{...}. À chaque itération, nous enchaînons la chaîne avec la chaîne d'entrée droite à nouveau divisée sur les nouvelles lignes, indexée et incrémentée.

Celles-ci sont laissées sur le pipeline et l'implicite Write-Outputà la fin nous donne une sortie sous forme de tableau de chaînes, qui sont imprimées avec des retours à la ligne entre.

— AdmBorkBork
source
1

Japt -R , 8 7 octets

·íV· m¬

Essayez-le

Explication

             :Implicit input of strings U & V
·            :Split U on newlines
  V·         :Split V on newlines
 í           :Interleave
     m       :Map
      ¬      :  Join
             :Implicitly join with newlines and output

Alternative

·Ë+V·gE

Essayez-le

             :Implicit input of strings U & V
·            :Split U on newlines
 Ë           :Map over each element at index E and rejoin with newlines
   V·        :  Split V on newlines
     gE      :  Get the element at index E
  +          :  Append to the current element
             :Implicitly join with newlines and output
— Hirsute
source
1

Bash , 92 octets

a=();for b;do c=;while IFS= read -r d;do a[c++]+=$d;done<<<"$b";done;printf '%s\n' "${a[@]}"

Essayez-le en ligne!

Non golfé:

array=()                             # Initialize the array
for argument in "${@}"; do           # Loop over the arguments list
  index='0'                          # Reset the index
  while IFS='' read -r 'line'; do    # Loop over every line of the current argument
    array[index]+="${line}"          # Append the line to its corresponding place
    (( index++ ))                    # Increment the index
  done <<< "${argument}"             # End while loop
done                                 # End for loop
printf '%s\n' "${array[@]}"          # Print array's content

Exemples:

$ foo $'abc\ndef' $'123\n456'
abc123
def456

$ foo $'qwertyuiop\n asdfghjkl' $'Some other\nTextFiller'
qwertyuiopSome other
 asdfghjklTextFiller

$ foo \
>   $'  *  \n *** \n*****\n *** \n  *  \n' \
>   $'  +  \n  +  \n+++++\n  +  \n  +  \n'
  *    +  
 ***   +  
*****+++++
 ***   +  
  *    +  


# https://gist.github.com/nxnev/dad0576be7eb2996b860c320c01d0ec5
$ foo "$(< input1)" "$(< input2)" "$(< input3)" > output

J'en ai également une plus courte mais elle échoue si la deuxième readinstruction renvoie une valeur non nulle.

Bash , 55 octets

while IFS= read -r a;IFS= read b<&3;do echo "$a$b";done

Remarque: <&3ne semble pas fonctionner sur tio.run

Celui-ci utilise des descripteurs de fichiers ( 1et 3) au lieu d'arguments:

$ foo <<< $'qwertyuiop\n asdfghjkl' 3<<< $'Some other\nTextFiller'
qwertyuiopSome other
 asdfghjklTextFiller
— nxnev
source
1

Fusain , 8 octets

ＰθＭ⌕θ¶→η

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

 θ          First input
Ｐ           Print without moving the cursor
    θ       First input
     ¶      Literal newline
   ⌕        Find index
  Ｍ   →     Move that many squares right
       η    Implicitly print second input

Ajoutez 2 octets pour accepter plusieurs entrées:

ＦＡ«ＰιＭ⌕ι¶→

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

 Ａ          Input
Ｆ «         Loop over all entries
   Ｐι       Print current entry
     Ｍ⌕ι¶→  Move to next entry

Ajoutez 4 octets pour accepter l'entrée non complétée:

ＰθＭ⌈Ｅ⪪θ¶Ｌι→η

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

      θ         First input
       ¶        Literal newline
     ⪪          Split
    Ｅ           Map over each string
         ι      Current string
        Ｌ       Length
   ⌈            Maximum
  Ｍ       →     Move that many squares right
— Neil
source
1

Swift 4 , 119 octets

func f(s:[String])->String{return s[0].split{$0=="\n"}.enumerated().map{$0.1+s[1].split{$0=="\n"}[$0.0]+"\n"}.joined()}

Explication

func f(s: [String]) -> String {
    return s[0].split{ $0=="\n" }       //splitting the first string after every \n
    .enumerated()                       //create a tuple of offsets and elements
    .map {
        $0.1 +                          //current element
        s[1].split{$0 == "\n"}[$0.0] +  //splitting the second string + indexing
        "\n"                            //new line after every line
     }
     .joined()
}

Essayez-le en ligne!

— Tamás Sengel
source
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.