Натхнення. * Я не можу повірити, що раніше у нас не було цього завдання:

Завдання

З огляду на один або кілька рядків для друку ASCII, переплітайте їх, беручи по одному символу з кожного рядка, циклічно, поки не залишилися символи. Якщо рядок не вистачає символів перед іншими, просто пропустіть цей файл з цього моменту.

Приклади

SIMPLE дає SIMPLE

POLLSі EPEESдаєPEOPLELESS

LYESі APRONSдаєLAYPERSONS

ABCDEі a cі 123 567даєAa1B 2Cc3D E567

"\n$?*і ​(порожній рядок) і ,(.)" (пробіл) дає ",\(n.$)?"* (пробіл)

^{* Є більш короткі рішення APL.}

Желе , 1 байт

Z

Спробуйте в Інтернеті!

Вбудований вбудований "транспоніст" зробить саме це до списку рядків.

Python 2, 101 89 86 69 байт

Я сподіваюся, що я можу це якось перетворити на лямбду, скорочуючи його, роблячи його рекурсивним. Це не ідеально, тому що ви сподіваєтесь, що транспортування коротше, на жаль, це не так (з того, що мені вдалося придумати поки що).

f=lambda s:' '*any(s)and''.join(x[:1]for x in s)+f([x[1:]for x in s])

Старі рішення:

w=input();o=''
while any(w):
 for i in range(len(w)):o+=w[i][:1];w[i]=w[i][1:]
print o

lambda s:''.join(''.join([c,''][c<' ']for c in x)for x in map(None,*[list(y)for y in s]))

w=input();o=''
while any(x>=' 'for x in w):
 for i in range(len(w)):o+=w[i][:1];w[i]=w[i][1:]
print o

^{завдяки математиці за те, що я почуваюсь німим;) врятував мене купу байтів! (за старим рішенням)}

Perl 6 , 34 32 байти

{[~] flat roundrobin |$_».comb}

{roundrobin(|$_».comb).flat.join}

Лямбда, яка приймає масив рядків як аргумент і повертає рядок.

( Спробуйте в Інтернеті )

CJam , 4 байти

qN/z

Спробуйте в Інтернеті!

Ми також можемо записати неназвану функцію на 4 байти, яка очікує список рядків у верхній частині стека:

{zs}

Спробуйте в Інтернеті!

Pyth - 3 байти

Дуже просто, додасть розширення пізніше, на мобільний.

s.T

Тестовий сюїт

s                         Join all the strings together
 .T                       Transpose, without chopping off overhang
  (Q implicit)

JavaScript (ES6), 52 46 байт

f=([[c,...s],...a])=>s+a?c+f(s+s?[...a,s]:a):c

Приймає введення як масив рядків, а виводить як один рядок.

Фрагмент тесту

f=([[c,...s],...a])=>s+a?c+f(s+s?[...a,s]:a):c

g=a=>console.log("Input:",JSON.stringify(a),"Output:",JSON.stringify(f(a)))

g(["SIMPLE"])
g(["POLLS","EPEES"])
g(["LYES","APRONS"])
g(["ABCDE","a c","123 567"])
g(["\"\\n$?*",",(.)\" "]) // Backslash and quote are escaped, but in/output are correct

Haskell, 33 байти

import Data.List
concat.transpose

Спробуйте це на Ideone. Використання:

Prelude Data.List> concat.transpose$["ABCDE","a c","123 567"]
"Aa1B 2Cc3D E567"

Без використання вбудованої програми: ( 38 34 байти)

f[]=[]
f x=[h|h:_<-x]++f[t|_:t<-x]

Спробуйте це на Ideone. 4 байти від Zgarb! Використання:

Prelude> f["ABCDE","a c","123 567"]
"Aa1B 2Cc3D E567"

C, 114 84 байт

-20 байт для не обчислення довжини.

i,b;f(char**s){b=1;while(b){i=-1;b=0;while(s[++i]>0)if(*s[i])putchar(*s[i]++),++b;}}

Приймає масив покажчиків char та вимагає, щоб останній елемент був нульовим покажчиком (див. Використання).

Безголівки та використання:

i,b;f(char**s){
 b=1;
 while(b){
  i=-1;
  b=0;
  while(s[++i]>0)
   if(*s[i])
    putchar(*s[i]++),++b;
 }
}


int main(){
 char*a[]={ 
//  "POLLS","EPEES"
//  "LYES","APRONS"
 "ABCDE","a c","123 567"
 ,0};
 f(a);
 puts("");
}

PHP, 68 67 байт

for(;$f=!$k=$f;$i++)for(;y|$v=$argv[++$k];$f&=""==$c)echo$c=$v[$i];

Петлі над аргументами командного рядка. Бігайте з -r.

Після внутрішнього циклу - $fце 1коли всі рядки закінчені, 0інакше (розрядне &відкидання ""==$cдо int).
Наступна ітерація зовнішньої петлі: скопіюйте $fв $k(зберігає один байт від $k=0) та перемкніть $f:
Коли всі рядки виконані, $fзараз falseі цикл розбивається.

Сітківка , 13 байт

Кількість байтів передбачає кодування ISO 8859-1.

O$#`.
$.%`
¶

Спробуйте в Інтернеті!

Пояснення

O$#`.
$.%`

Це засновано на стандартній техніці транспозиції у сітківці. Сортуємо ( O) всі символи, що не передаються в рядку ( .), за ($# в рядку ( $.%`), ) кількістю символів перед ними в одному рядку ( ), тобто їх горизонтальним положенням.

Другий етап потім просто видаляє канали ліній із входу.

Ява, 19 + 155 = 174 160

String f(java.util.Queue<String> q){String s,r="";while(!q.isEmpty()){s=q.poll();r+=s.isEmpty()?"":s.charAt(0);if(s.length()>1)q.add(s.substring(1));}return r;}

Безголовки:

  String f(java.util.Queue<String> q) {
    String s, r = "";
    while (!q.isEmpty()) {
      s = q.poll();
      r += s.isEmpty() ? "" : s.charAt(0);
      if (s.length() > 1) {
        q.add(s.substring(1));
      }
    }
    return r;
  }

Вихід:

ПРОСТО

ЛЮДИНА

ЛАЙПЕРСОНИ

Aa1B 2Cc3D E567

", (n. $)?" *

Перша модифікація: об'єднане рядкове оголошення для збереження деяких байтів. Вилучений import, він використовувався main()методом (не показаний тут), який також потрібен LinkedList. Це менше байтів для Queueпрямого визначення.

PHP, 77 байт

Гольф

function($a){for($d=1;$d!=$s;$i++){$d=$s;foreach($a as$v)$s.=$v[$i];}echo$s;}

Анонімна функція, яка займає масив рядків.

Я впевнений, що на цьому можна було б більше гольфу, але це рано. На кожній ітерації ми витягуємо i-й лист з кожного заданого рядка і додаємо його до остаточного рядка, по одному. PHP просто кидає попередження, якщо ми отримуємо доступ до бітів рядків, які не існують, тож це добре. Ми зупиняємось лише тоді, коли жодних змін не було зроблено після прокручування всіх рядків один раз.

Я відчуваю, що за використання $dможна більше пограти в гольф, але це рано. : P

Насправді , 7 6 байт

Пропозиції з гольфу вітаються! Спробуйте в Інтернеті!

Редагувати: -1 байт завдяки пелікану Teal.

a Z♂ΣΣ

Ungolfing

          Implicit input each string.
a         Invert the stack so that the strings are in the correct order.
<space>   Get the number of items on the stack, len(stack).
Z         Zip all len(stack) strings into one, transposing them.
♂Σ        sum() every transposed list of chars into strings.
Σ         sum() again to join the strings together.

JavaScript (ES6), 46 байт

f=([[c,...s],...a])=>c?c+f([...a,s]):a+a&&f(a)

<textarea oninput=o.textContent=f(this.value.split`\n`)></textarea><div id=o>

Python 2 , 58 байт

lambda*m:''.join(map(lambda*r:''.join(filter(None,r)),*m))

Спробуйте в Інтернеті!

J , 13 байт

({~/:)&;#\&.>

Спробуйте в Інтернеті!

Виходячи з натхнення для цього питання.

Інший спосіб зробити це займає 27 байтів, але працює за допомогою транспонінгу. Більшість байтів мають обробляти автоматично додані нулі від прокладки.

[:u:0<:@-.~[:,@|:(1+3&u:)&>

Пояснення

({~/:)&;#\&.>  Input: list of boxed strings S
          &.>  For each boxed string x in S
        #\       Get the length of each prefix from shortest to longest
                 This forms the range [1, 2, ..., len(x)]
                 Rebox it
(    )         Operate on S and the prefix lengths
      &;         Raze both
   /:            Grade up the raze of the prefix lengths
 {~              Index into the raze of S using the grades
               Return

Утиліти Bash + GNU, 55

 eval paste `sed "s/.*/<(fold -1<<<'&')/g"`|tr -d \\n\\t

Введення / виведення через STDIN (розділений рядком) та STDOUT.

sedФорматує кожен рядок до заміщенню процесу Баша . Потім вони evalредагуються, pasteщоб зробити фактичне переплетення. trпотім видаляється непотрібні нові рядки та вкладки.

Ідеон.

PHP, 63 байти

Примітка: використовує кодування IBM-850

for(;$s^=1;$i++)for(;n|$w=$argv[++$$i];$s&=$x<~■)echo$x=$w[$i];

Бігайте так:

php -r 'for(;$s^=1;$i++)for(;n|$w=$argv[++$$i];$s&=$x<~■)echo$x=$w[$i];' "\"\n\$?*" "" ",(.)\" " 2>/dev/null;echo
> ",\(n.$)?"* 

Пояснення

for(                       # Iterate over string index.
  ;
  $s ^= 1;                 # Continue until $s (stop iterating) is 1.
                           # Flip $s so each iteration starts with $s
                           # being 1.
  $i++                     # Increment string index.
)
  for(
    ;
    "n" | $w=$argv[++$$i]; # Iterate over all input strings. OR with "n"
                           # to allow for empty strings.
    $s &= $x<~■            # If last character printed was greater than
                           # \x0 (all printable chars), set $s to 0,
                           # causing the loop to continue.
  )
    echo $x = $w[$i];      # Print char $i of current string.

Пітон 3, 75 байт

Я знаю, що інший Python коротший, але це перший раз, коли я використовував mapу своєму житті, тому я дуже пишаюся цим

lambda n:''.join(i[k]for k in range(max(map(len,n)))for i in n if len(i)>k)

C, 75 71 байт

Єдине обмеження - це вихідна довжина. Наразі це 99, але їх можна легко розтягнути до 999 (+1 байт).

i;main(a,b)char**b;{a--;for(;i<99;i++)*b[i%a+1]&&putchar(*b[i%a+1]++);}

Безголовки:

i;
main( a, b )
char **b;
{
    a--;
    for( ; i < 99; i++ )
        *b[i % a + 1] && putchar( *b[i % a + 1]++ );
}

Oracle SQL, 195 байт

    select listagg(b,'') within group(order by l,o) from(select substr(a,level,1) b,level l,o from i start with length(a)>0 connect by prior a=a and level<=length(a) and prior sys_guid() is not null)

Бере свій вхід із таблиці, названої iстовпцями a(що містять рядок) та o(порядок рядка):

    create table i (a varchar2(4000), a integer)

Пояснення:
Ми використовуємо CONNECT BYдля розбиття рядків у кожного з персонажів, що їх складають. PRIOR SYS_GUID()будучи NOT NULLгарантованим, що ми не опинимося в петлі.
Потім ми поєднуємо одиничні символи, LISTAGGале перетасовуємо їх навколоORDER BY пункту, упорядковуючи їх спочатку за місцем розташування в початковій рядку і лише потім за рядком, з якого вони походять.

Не такий короткий, як інші відповіді, але SQL насправді не розуміється як мова маніпулювання рядком :)

Пітон 2, 128 96

Я сподівався, що не доведеться використовувати itertools

a=lambda a:"".join([i for i in reduce(lambda: b,c:b+c, map(None,*map(lambda m:list(m),a)) if i])

Безумовно

 a=lambda a:                              #Start a lambda taking in a
    "".join(                              #Join the result together with empty string
        [i for i in reduce(               #For every item, apply the function and 'keep'
           lambda: b,c:b+c,               #Add lists from...
                map(None,*map(            #None = Identity function, over a map of...
                    lambda m:list(m), a)  #list made for mthe strings m
                   ) if i                 #truthy values only (otherwise the outer map will padd with None.
       ])

Perl 5 , 28 байт

26 байт код + 2 для -0n.

s/^./!print$&/gem while/./

Спробуйте в Інтернеті!

R , 73 байти

for(i in 1:max(nchar(s<-scan(,""))))for(j in seq(s))cat(substr(s[j],i,i))

Спробуйте в Інтернеті!

Пояснення: дуже просте (але багатослівне), просто проведіть печатку над iсимволом jth рядка. На щастя, substrповертає порожній рядок, якщо вводиться поза діапазоном.

Пітон, 112 байт

i=len(x)if len(x)>len(y) else len(y) h=0 a="" while h<i: if h<len(x) a+=x[h] if h<len(y): a += y[h] h+=1 print a

Perl 5 , 53 байти

$i=0,map{push@{$a[$i++]},$_}/./g for<>;print@$_ for@a

Спробуйте в Інтернеті!

Метод

Створює двовимірний масив, де кількість рядків дорівнює довжині найдовшої рядки, а максимальна кількість стовпців дорівнює кількості рядків. Потім виведіть кожен рядок масиву без пробілів.

TXR Lisp , 20 байт

(opip weave cat-str)

Виконати:

1> (opip weave cat-str)
#<intrinsic fun: 0 param + variadic>
2> [*1 "LYES" "APRONS"]
"LAYPERSONS"
3> [*1 "ABCDE" "a c" "" "123 567"]
"Aa1B 2Cc3D E567"
4> [*1 "\"\\n$?*" "" ",(.) "]
"\",\\(n.$)? *"

weaveФункція лінива, тому він повертає список, тому ми повинні змусити результат в рядок. Будучи ледачим, він може плести нескінченні послідовності. Наприклад, ми можемо сплести парні і непарні натуральні числа, які самі є нескінченними ледачими списками:

5> (take 20 (weave (range 2 : 2) (range 1 : 2)))
(2 1 4 3 6 5 8 7 10 9 12 11 14 13 16 15 18 17 20 19)

K (oK) , 35 29 байт

Рішення:

{`c$r@&~^r:,/+(`i$x)[;!#,/x]}

Спробуйте в Інтернеті!

Приклад:

> {`c$r@&~^r:,/+(`i$x)[;!#,/x]}("ABCDE";"a c";"123 567")
"Aa1B 2Cc3D E567"
> {`c$r@&~^r:,/+(`i$x)[;!#,/x]}("\n$?*";"";",(.)\" ")
"\n,$(?.*)\" "
> {`c$r@&~^r:,/+(`i$x)[;!#,/x]}("POLLS";"EPEES")
"PEOPLELESS"

Пояснення:

Використовуйте індексацію другого рівня, щоб витягнути індекси від 0 до макс (довжина сплющеного списку) для всіх списків введення. Будь-яка індексація за межами підсписку поверне нуль. Переверніть (обертається на 90), вирівняйте та витягніть ненулі результати.

Примітки:

• Я кидаю на integer ( i$), щоб ми отримували корисні нулі, оскільки пробіл ( ) вважається нульовим для списку знаків, що означає, що ви не можете сказати нулі з дійсних пробілів.
• Крім того, я не міг змусити TIO працювати з введенням (добре працював в oK repl), тому TIO-посилання включає в себе "ABCDE" ... приклад.

Jq 1,5 , 49 байт

map(explode)|transpose|map(map(values)[])|implode

Пояснення

                      # example input:          ["LYES","APRONS"]
  map(explode)        # make list of ordinals   [[76,89,69,83],[65,80,82,79,78,83]]
| transpose           # zip lists               [[76,65],[89,80],[69,82],[83,79],[null,78],[null,83]]
| map(map(values)[])  # rm nulls and flatten    [76,65,89,80,69,82,83,79,78,83]
| implode             # convert back to string  "LAYPERSONS"

Виконання зразків

$ paste input <(jq -Mrc 'map(explode)|transpose|map(map(values)[])|implode' input)
["SIMPLE"]                  SIMPLE
["POLLS","EPEES"]           PEOPLELESS
["LYES","APRONS"]           LAYPERSONS
["ABCDE", "a c", "123 567"] Aa1B 2Cc3D E567
["\"\\n$?*", "", ",(.)\" "] ",\(n.$)?"* 

$ echo -n 'map(explode)|transpose|map(map(values)[])|implode' | wc -c
  49    

Спробуйте в Інтернеті