(Ispirato da questa sfida )

Dato due stringhe di input, una delle quali è esattamente un carattere più lungo dell'altra, disponi le stringhe nell'arte ASCII come se fossero due metà di una cerniera che è solo a metà cerniera. La parola più lunga costituisce il fondo della cerniera, ed è il primo e l'ultimo carattere della porzione combinata con cerniera. Dal momento che quel paragrafo è difficile da capire, dai un'occhiata ad alcuni esempi:

zippered
paragraph

 z
   i
     p
       p
        gerraepdh
      a
    r
  a
p

Nota come paragraph(la parola più lunga) forma la cerniera inferiore, e la g r a p hporzione incapsula la e r e dporzione di zippered, e le porzioni z i p pe p a r asono sfalsate l'una dall'altra.

Ingresso

• Due stringhe ASCII in qualsiasi formato conveniente , con una garantita di lunghezza uniforme e l'altra esattamente un carattere più lungo.
• Nessuna delle stringhe conterrà spazi bianchi, ma può contenere qualsiasi altro valore ASCII stampabile.
• Puoi prendere l'input in entrambi gli ordini. Si prega di indicare nell'invio l'ordine di input.

Produzione

La rappresentazione artistica ASCII risultante delle parole con cerniera, come descritto sopra, sempre in qualsiasi formato conveniente.

Regole

• Le nuove linee iniziali o finali o gli spazi bianchi sono tutti opzionali, purché i personaggi stessi si allineino correttamente.
• È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
• Se possibile, includi un collegamento a un ambiente di test online in modo che altre persone possano provare il tuo codice!
• Sono vietate le scappatoie standard .
• Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

Esempi

ppcg
tests

 p
   p
    sctgs
  e
t

string
strings

 s
   t
     r
      iinnggs
    r
  t
s

Japt , 31 28 byte

N®¬£ç iXYm½*Ul
uUo mw
y c ·y

Provalo online! Prende prima la stringa più corta.

Spiegazione

N®¬£ç iXYm½*Ul    First line: Set U to the result.
N®                Map each item (there's exactly 2 of them) in the input to
  ¬                 the item split into chars,
   £                with each item X and index Y mapped to
    ç                 the first input filled with spaces,
      iX              with X inserted at index
        Ym½*Ul          min(Y, 0.5 * U.length).
                  At the end each input is an array like
                  ["p    ", " p   ", "  c  ", "  g  "]
                  ["t    ", " e   ", "  s  ", "  t  ", "  s  "]

uUo mw    Second line: Set V to the result (though that's not important).
 Uo       Pop the last item (the array representing the second string) from U.
    m     Map each item by
     w      reversing.
u         Push the result to the beginning of U.
          At the end we have e.g.
          ["    t", "   e ", "  s  ", "  t  ", "  s  "]
          ["p    ", " p   ", "  c  ", "  g  "]

y c ·y    Last line: Output the result of this line.
y         Transpose: map [[A,B,C,...],[a,b,c,...]] to [[A,a],[B,b],[C,c],...].
  c       Flatten into one array. [A,a,B,b,C,c,...]
    ·     Join on newlines. Now we have the output transposed.
     y    Transpose rows with columns.

Carbone , 33 31 byte

→Ｆ²«ＦＬ諧θκ→¿‹κ÷Ｌθ²¿ι↑↓»Ｊ⁰ＬθＡηθ

Provalo online! Il collegamento è alla versione dettagliata del codice. Prende prima la stringa più corta. Modifica: salvato 2 byte modificando il rilevamento del punto medio. Spiegazione:

→Ｆ²«

Passa sopra ogni stringa a turno.

ＦＬθ«

Passa sopra ogni carattere della stringa a sua volta.

§θκ→

Stampa il personaggio e sposta un riquadro aggiuntivo a destra.

¿‹κ÷Ｌθ²¿ι↑↓»

Per la prima metà della stringa, spostare anche il cursore verso il basso o verso l'alto, come appropriato.

Ｊ⁰ＬθＡηθ

Dopo aver stampato la prima stringa, passa al punto iniziale della seconda stringa e sostituisci la prima con la seconda, in modo che venga stampata per il secondo ciclo. (Il codice viene eseguito su entrambi i loop, ma la seconda volta è un no-op.)

Pyth , 35 byte

AQj.t.e+*d+lG*<klH*^_1k/h-lGk2b.iHG

Provalo online!

Gelatina ,  27  26 byte

-1 byte grazie a Erik the Outgolfer (utilizzare ripetizione,, ¡per sostituire if ?, e una clausola passato passata ¹)

JCḂ¡€ṚH
żµL⁶ẋ;ЀFṙ"ÇZṙÇṀ$Y

Un programma completo che stampa il risultato con spazi vuoti iniziali, come consentito nella domanda (o un collegamento diadico che restituisce un elenco di caratteri).

Provalo online!

Come?

JCḂ¡€ṚH - Link 1, get rotations: list p        e.g.: ["a1","b2","c3","d4","e5","f6","g"]
J       - range of length of p                       [ 1, 2, 3, 4, 5, 6, 7]
    €   - for €ach:
   ¡    -   repeat link:
  Ḃ     - ...# of times: modulo 2                      1  0  1  0  1  0  1
 C      - ...link: complement (1-x)                    0  2 -2  4 -4  6 -6
     Ṛ  - reverse                                    [-6, 6,-4, 4,-2, 2, 0]
      H - halve                                      [-3, 3,-2, 2,-1, 1, 0]

żµL⁶ẋ;ЀFṙ"ÇZṙÇṀ$Y - Main link: longer (odd length); shorter (even length)
                   -                           e.g.: "abcdefg", "123456"
ż                  - zip them together               ["a1","b2","c3","d4","e5","f6","g"]
 µ                 - monadic chain separation, call that p
  L                - length of p                     7
   ⁶               - literal space character         ' '
    ẋ              - repeat                          "       "
        F          - flatten p                       "a1b2c3d4e5f"
      Ѐ           - map with:
     ;             -   concatenation                 ["       a","       1","       b","       2","       c","       3","       d","       4","       e","       5","       f","       6","       g"]
           Ç       - call last link (1) as a monad with argument p
          "        - zip with (no action on left by trailing values of right):
         ṙ         -   rotate left by                ["  a     ","    1   "," b      ","     2  ","c       ","      3 ","       d","       4","       e","       5","       f","       6","       g"]
            Z      - transpose                       ["    c        ","  b          ","a            ","             "," 1           ","   2         ","     3       ","      d4e5f6g"]
                $  - last two links as a monad:
              Ç    -   call last link (1) as a monad with argument p
               Ṁ   -   maximum                       3
             ṙ     - rotate left by                  ["             "," 1           ","   2         ","     3       ","      d4e5f6g","    c        ","  b          ","a            "]
                 Y - join with newlines            '''             \n
                                                       1           \n
                                                         2         \n
                                                           3       \n
                                                            d4e5f6g\n
                                                          c        \n
                                                        b          \n
                                                      a            '''
                   - as full program: implicit print

Python 2 , 128 119 byte

f=lambda a,b,n=0:n/2<len(a)and' '*-~n+a[0]+'\n'+f(a[1:],b[1:],n+2)+'\n'+' '*n+b[0]or' '*n+''.join(sum(zip(b,a+' '),()))

Provalo online!

V , 47 38 30 27 26 25 byte

Finalmente battere l'attuale risposta Jelly \ o /

Accetta input con la parola più lunga in alto

Spiegazione in arrivo, non pensare che ci sia molto altro da golf.

òGxplòxãòd|>HÏpd|>GGÏphl

Provalo online!

Spiegazione

ò     ò      ' <M-r>ecursively
             |abc
             def
 Gx          ' (G)oto the last line and (x) the first character
             abc
             |ef
            ' <C-O> Go back to the previous location
             |abc
             ef
    p        ' (p)aste the character cut
             a|dbc
             ef
     l       ' move one character right
             ad|bc
             ef

x                  ' (x) the last extraneous character from the previous loop
 ã                 ' <M-c>enter the cursor
  ò                ' <M-r>ecursively
   d|              ' (d)elete to the first co(|)umn
     >H            ' (>) Indent every line from here to (H)ome (first line)
                   ' this leaves the cursor on the first line
       Ïp          ' <M-O>n a newline above this (the first) (p)aste the deleted section
                   ' this leaves the cursor on the last character
         d|        ' (d)elete to the first co(|)umn
           >G      ' (>) Indent every line from here to the end (G)
                   ' unfortunately the cursor stays on the first line
             G     ' (G)oto the last line
              Ïp   ' <M-O>n a newline above this (the last) (p)aste the deleted section
                hl ' move left and then right (break the loop at the end)

V , 79 byte

ãl}dÍ./ &
XòYf D"0Pr -Y;D"0pr +òGï"1pÓ./&ò
}dGÓ/&ò
{jpògJòÓó
|DÇ./d
MÙ"-pBr 

Provalo online!

Quanto segue dovrebbe essere letto con un sacco di sarcasmo e citazioni aeree .

Ecco una risposta nel mio linguaggio per il golf che è utile per brevi risposte a sfide basate su stringhe e in arte ASCII .

Perché continuo a farmi questo?

hexdump:

00000000: e36c 167d 64cd 2e2f 2026 0a58 f259 6620  .l.}d../ &.X.Yf 
00000010: 4422 3050 7220 2d59 3b44 2230 7072 202b  D"0Pr -Y;D"0pr +
00000020: f247 ef22 3170 d32e 2f26 f20a 0f16 7d64  .G."1p../&....}d
00000030: 47d3 2f26 f20a 7b6a 70f2 674a f2d3 f30a  G./&..{jp.gJ....
00000040: 7c44 c72e 2f64 0a4d d922 2d70 4272 20    |D../d.M."-pBr 

Gelatina , 28 byte

HĊ©«Rµ®Ḥ_,Ṗ
ZLÇṬ€a"¥"o⁶ZẎz⁶Y

Provalo online!

Woo Jelly è in realtà in competizione in una stringa e sfida di arte ascii ! \ o /

05AB1E , 26 23 byte

øS2ä`JIθ«¸«vyNúr})2äR˜»

Provalo online!

Spiegazione

Con esempio input = ppcg, tests

ø                           # zip the input strings
                            # STACK: ['tp', 'ep', 'sc', 'tg']
 S                          # split to a list of characters
                            # STACK: ['t', 'p', 'e', 'p', 's', 'c', 't', 'g'
  2ä                        # divide the list into 2 parts
    `                       # push them as separate to stack
                            # STACK: ['t', 'p', 'e', 'p'], ['s', 'c', 't', 'g']
     J                      # join the second part to a single string
      Iθ«                   # append the tail of the second input
         ¸«                 # concatenate the 2 lists
                            # STACK: ['t', 'p', 'e', 'p', 'sctgs']
           v                # for each y,N (element, index) in the list
            yNú             # prepend N spaces to y
               r            # reverse the stack
                })          # end loop and wrap the stack in a list
                            # STACK: ['    sctgs', '  e', 't', ' p', '   p']
                  2ä        # split the list into 2 parts
                    R       # reverse the list
                            # STACK: [[' p', '   p'], ['    sctgs', '  e', 't']]
                     ˜»     # flatten the list and join on newlines

C # (.NET Core) , 163 byte

(l,s)=>{var o="";int i=0,k=s.Length;for(;i<k;)o+=i<k/2?s[i++]+"\n"+"".PadLeft(i):l[i]+""+s[i++];o+=l[i]+"\n";for(i=k/2;i>0;)o+="".PadLeft(--i)+l[i]+"\n";return o;}

Provalo online!

Probabilmente molto golf da fare qui, ma ecco un tentativo iniziale non LINQ. Funzione lambda che accetta prima la parola più lunga e restituisce una stringa con l'ouput.

Java 8, 216 byte

Una lambda al curry: prende Stringe restituisce una lambda da Stringa String. Il parametro per la lambda esterna è la stringa più corta.

Non essere in grado di indicizzare in Strings con la sintassi dell'array è ... sfortunato.

s->t->{int l=s.length(),i=l/2;String o="",p=o,n="\n";for(;i<l;p+="  ")o=o+t.charAt(i)+s.charAt(i++);o=p+o+t.charAt(i)+n;for(;i-->0;)o=p.substring(l-i--)+s.charAt(i/2)+n+o+p.substring(l-i)+t.charAt(i/2)+n;return o;}

Lambda ungolfed

s ->
    t -> {
        int
            l = s.length(),
            i = l / 2
        ;
        String
            o = "",
            p = o,
            n = "\n"
        ;
        for (; i < l; p += "  ")
            o = o + t.charAt(i) + s.charAt(i++);
        o = p + o + t.charAt(i) + n;
        for (; i-- > 0; )
            o =
                p.substring(l-i--)
                + s.charAt(i / 2)
                + n
                + o
                + p.substring(l-i)
                + t.charAt(i / 2)
                + n
            ;
        return o;
    }

Spiegazione

lè la lunghezza dell'input più corto ed iè un indice multiuso, inizializzato per fare riferimento al primo carattere della seconda metà dell'input più corto. oaccumula il risultato, alla pfine memorizza gli spazi per il riempimento ed nè un alias per"\n" .

Il primo ciclo interlaccia le seconde metà delle due stringhe (escluso l'ultimo carattere dell'input più lungo) e costruisce palla giusta quantità di riempimento per la linea di mezzo.

La riga successiva completa la riga centrale dell'output.

Vorrei scusarmi con James Gosling per il secondo giro. Aggiunge le linee sopra e sotto la linea mediana dall'interno verso l'esterno. Entrando nel ciclo, iè l - 1, quindi viene anteposto un carattere di riempimento insieme all'ultimo carattere della prima metà della stringa più corta.iviene decrementato in modo tale che il padding successivo (aggiunto al risultato) sia un carattere più breve. Per divisione intera, viene aggiunto lo stesso carattere di posizione della stringa più lunga. Ciò si ripete e viene restituito il risultato completo.

Roba forte

La linea 13 era una volta

o+=t.charAt(i)+""+s.charAt(i++);

perché senza la stringa vuota, ha +aggiunto i valori dei caratteri insieme e ha aggiunto una stringa numerica. Espandendo l'assegnazione composta, la concatenazione di oe t.charAt(i)viene valutata per prima, il che produce il risultato desiderato senza bisogno della stringa vuota, risparmiando 2 byte. Questa è la prima volta che vedo un incarico composto comportarsi diversamente dalla sua espansione.

Javascript (ES6), 140 137 133 byte

A=(a,b,c=0)=>a[c/2]?` `[d=`repeat`](c+1)+a[0]+`
`+A(a.slice(1),b.slice(1),c+2)+`
`+` `[d](c)+b[0]:` `[d](c)+[...a].map((e,f)=>e+b[f])

Abbastanza sicuro questo può essere ulteriormente giocato a golf

Mathematica, 174 byte

(a=(c=Characters)@#;b=c@#2;T=Table;Column[Join[T[T["  ",i]<>a[[i]],{i,g=Length@a/2}],{T["  ",g+1]<>Riffle[b[[-g-1;;]],a[[-g;;]]]},Reverse@T[T["  ",i]<>b[[i+1]],{i,0,g-1}]]])&

Ingresso

["zippato", "paragrafo"]

TXR Lisp , 126 byte

(defun f(a b :(n 0))(if(<(/ n 2)(length a))` @{""n}@[a 0]\n@(f(cdr a)(cdr b)(+ n 2))\n@{""n}@[b 0]``@{""n}@{(zip b`@a `)""}`))

PHP, 149 129 byte

for($r=" ";$x+1<$w=2*$e=strlen($argv[2]);++$x&1||$r[++$i*$w-1]="
")$r[$w*($x&1?$y-1:$e-$y+=$y<$e/2)+$x]=$argv[2-$x%2][$i];echo$r;

Corri con -nro provalo online .

Perl 5 , 163 byte

@a=map{$s=.5*length;[/./g]}<>;say(($"x(2*$_)).$a[0][$_])for 0..$s-1;print$"x(2*$s);print$a[0][$_].$a[1][$_]for$s..@{$a[1]};print$/.($"x(1+2*$s)).$a[1][$s]while$s--

Provalo online!

Prende prima la stringa più lunga.