Horizontal ausgerichtet ASCII Art.-Nr.

20

Ihre Aufgabe ist es, zwei "ASCII Art" als Eingabe zu akzeptieren und jedes Kunstwerk horizontal nebeneinander auszurichten.

Angenommen, Sie haben zwei Zeichenfolgen "abc\ndef"und "123\n456". Sie müssen sie horizontal ausrichten, um die Zeichenfolge zu erzeugen. "abc123\ndef456"Ich bezeichne dies als" horizontal ausrichten ", da die Eingaben beim Drucken wie folgt aussehen:

abc
def

und:

123
456

Die Ausgabe sieht beim Drucken folgendermaßen aus:

abc123
def456

Beachten Sie, wie ein Eingang neben dem anderen platziert wird.

Eingang

  • Die Eingabe erfolgt als Zeichenfolge und kann als zwei separate Argumente oder als Folge von Zeichenfolgen erfolgen.
  • Die Zeichen in den Künsten haben Dezimalcodes im Bereich von 32-126 (einschließlich).
  • Es ist in Ordnung, eine beliebige Anzahl von Künsten anstelle von nur zwei zu unterstützen (aber offensichtlich müssen Sie mindestens zwei unterstützen).
  • Sie können davon ausgehen, dass jedes Bild die gleichen Abmessungen hat und mindestens eine Zeile enthält.

  • Sie müssen mindestens 100x100 Zeichen unterstützen können.

  • Um sich an die Konventionen auf der Site anzupassen, spielt die Reihenfolge der Argumente keine Rolle. Es ist egal, welche Kunst links oder rechts ist.

Ausgabe

  • Die Ausgabe erfolgt nach den oben genannten Regeln, entweder als Rückgabe oder als Ausgabe an die Standardausgabe.

  • Alle nachfolgenden Leerzeichen sind optional.

  • Es darf keine visuelle Trennung zwischen den ausgerichteten Künsten geben.

Eingabe- und Ausgabekünste müssen Zeichenfolgen sein \noder voneinander getrennt werden \r. Es wäre zu trivial, 2D-Arrays zuzulassen.

Einsendungen können Funktionen oder vollständige Programme sein.

Testfälle:

"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 
— Karzigenat
quelle
1
Können wir ein benutzerdefiniertes Trennzeichen anstelle von Zeilenumbrüchen verwenden? dh "|"oder " "?
— 16.
10
Ich sage nein, das würde jede Kunst ruinieren.
— Carcigenicate
Dürfen wir \rstatt verwenden \n?
— Adám
@ Adám Sicher. Ich werde den Wortlaut aktualisieren.
— Carcigenicate
Ist führendes Leerzeichen in Ordnung?
— Adám

Antworten:

20

Canvas , 1 Byte

×

Probieren Sie es hier aus!

— dzaima
quelle
6
Denn wer hat nicht gerade ein eingebautes dafür? : P
— Caird Coinheringaahing
5
Das ist nicht mal fair. ; -;
— Totalhuman
3
@KevinCruijssen In PPCG ist es normalerweise zulässig, Eingaben in beliebiger Reihenfolge vorzunehmen, und für eine Stack-basierte Sprache ist die aktuelle Reihenfolge sinnvoller als umgekehrt.
— Dzaima
5
@ KevinCruijssen obwohl ich mich gerade daran erinnerte, dass ich ein eingebautes Reverse-Add habe, so aktualisiere ich den Beitrag: p
— dzaima
2
Also hat Canvas zwei Builtins dafür? OK warum nicht?
— Caird Coinheringaahing
6

Python 2 , 59 Bytes

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

Probieren Sie es online!

— Rɪᴋᴇʀ
quelle
Sie kann auch durch Entfernen des Leerzeichens verkürzt werden. : P
— totalhuman
Wenn Sie wie zuvor Zeilenlisten ein- und ausgeben möchten, können Sie es auf 30 reduzieren
Ich saß ungefähr 5 Minuten da und versuchte zu entscheiden, ob ich das zulassen sollte. Wie die Antwort von Haskell zeigt, würde dies die Herausforderung auf etwas viel Trivialeres reduzieren. Ich nehme an, dass die allzu trivialen Lösungen einfach nicht so populär wären.
— Carcigenicate
3

Perl 5 -0F , 28 Bytes

Includes +2für das \nArgument to -F(es ist "Code", also sollte es zählen)

Geben Sie die Eingaben direkt nacheinander auf STDIN.

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

Probieren Sie es online!

— Tonne Hospel
quelle
2

APL (Dyalog Unicode) , 9 Byte SBCS

Volles Programm. Fordert (STDIN) zur Eingabe einer beliebigen \rLängenliste von Zeichenfolgen mit Begrenzung auf. Die Saiten können ungleichmäßig und unterschiedlich breit sein, solange sie die gleiche Anzahl von Linien haben. Druckt (STDOUT) die resultierenden ASCII-Grafiken.

⊃,/⎕FMT¨⎕

Probieren Sie es online!

⎕ Eingabeaufforderung für ausgewertete Eingabe

⎕FMT¨ jeweils formatieren (alle Steuerzeichen auswerten und Zeichenmatrix zurückgeben)

,/ horizontal kombinieren (Verkettungsreduzierung)

⊃ enthüllen (weil die Reduktion den Rang von 1 auf 0 reduziert hat)

— Adam
quelle
2

Java 8, 100 84 78 Bytes

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

Beendet mit einem ArrayIndexOutOfBoundsExceptionan STDERR, nachdem das Ergebnis an STDOUT ausgegeben wurde, was zulässig ist .

-6 Bytes dank @ OlivierGrégoire .

Erläuterung:

Probieren Sie es online aus.

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
quelle
1
a->b->{for(int i=0;;)System.out.println(a.split("\n")[i]+b.split("\n")[i++]);}78 Bytes. Es wird nichts darüber gesagt, keine zusätzlichen Nebenwirkungen zu haben. Wir können also einfach zählen, bis eine Ausnahme auftritt.
— Olivier Grégoire
@ OlivierGrégoire Danke! Und das Beenden mit einem Fehler an STDERR ist in der Tat zulässig, nachdem alles an STDOUT gedruckt wurde.
— Kevin Cruijssen
2

Ruby , 48 Bytes

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

Probieren Sie es online!

Ein Lambda, der zwei Saiten nimmt und eine Saite zurückgibt. Wenn Sie das Standardtrennzeichen splitauf newline with setzen $;=$/;, werden keine Bytes gespeichert , aber der Rest sieht ein bisschen besser aus.

Ruby , 49 Bytes (beliebig viele Strings)

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

Probieren Sie es online!

Nur zum Spaß. Es stellt sich heraus, dass wir ein Array von Zeichenfolgen gegen einen Aufpreis von nur 1 Byte akzeptieren können.

— benj2240
quelle
2

JavaScript (ES6), 51 Byte

f=
(a,b)=>a.replace(/.+/g,a=>a+b.shift(),b=b.split`
`)
;document.write("<pre>"+f("abc\ndef", "123\n456")+"</pre>")
Erweitern Sie das Snippet

— Neil
quelle
2

Wunder , 21 Bytes

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

Anwendungsbeispiel:

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

#nwird anstelle von \nZeilenumbrüchen verwendet.

Erläuterung

Ausführliche Version:

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

Teilen Sie jede Zeichenfolge im Eingabearray entlang von Zeilenumbrüchen auf, komprimieren Sie sie mit verketteten Zeichenfolgen und geben Sie die einzelnen Elemente aus.

— Mama Fun Roll
quelle
1

PowerShell , 51 bis 49 Byte

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

Probieren Sie es online!

Nimmt Eingaben als wörtliche Zeichenfolgen mit Zeilenumbrüchen an. Sie können stattdessen auch `n(den Zeilenumbruchbegrenzer in PowerShell, nicht \n) verwenden.

Zuerst setzen wir -splitden linken Eingabestring in Zeilenumbrüche, wodurch ein Array erstellt wird, und durchlaufen diesen |%{...}. Bei jeder Iteration verketten wir die Zeichenfolge mit der richtigen Eingabezeichenfolge, die wiederum in Zeilenumbrüche aufgeteilt, indiziert und inkrementiert wird.

Diese Write-Outputverbleiben in der Pipeline, und der implizite Abschluss gibt die Ausgabe als Array von Zeichenfolgen aus, die mit Zeilenumbrüchen dazwischen gedruckt werden.

— AdmBorkBork
quelle
1

Japt -R , 8 7 Bytes

·íV· m¬

Versuch es

Erläuterung

             :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

Versuch es

             :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
— Zottelig
quelle
1

Bash , 92 Bytes

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

Probieren Sie es online!

Ungolfed:

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

Beispiele:

$ 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

Ich habe auch eine kürzere, aber es schlägt fehl, wenn die zweite readAnweisung einen Wert ungleich Null zurückgibt.

Bash , 55 Bytes

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

Hinweis: Scheint<&3 auf tio.run nicht zu funktionieren

Dieser verwendet Dateideskriptoren ( 1und 3) anstelle von Argumenten:

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

Kohle , 8 Bytes

ＰθＭ⌕θ¶→η

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

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

Fügen Sie 2 Bytes hinzu, um mehrere Eingaben zu akzeptieren:

ＦＡ«ＰιＭ⌕ι¶→

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

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

Fügen Sie 4 Bytes hinzu, um ungepolsterte Eingaben zu akzeptieren:

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

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

Schnelle 4 , 119 Bytes

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

Erläuterung

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

Probieren Sie es online!

— Tamás Sengel
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.