вход

Неотрицательное целое число nи непустая строка, sсодержащая только буквенно-цифровые символы и подчеркивания _. Первый персонаж sне является _. Подчеркивания sинтерпретируются как пробелы, которые могут быть заполнены другими символами.

Определим бесконечную последовательность «бесконечных строк» ​​следующим образом. Строка просто повторяется бесконечно много раз. Для всех строка получается путем заполнения ее пробелов символами , так что первое из заменяется на , второе - и так далее. Поскольку первая буква - нет , каждое пустое пространство в конце концов заполняется, и мы обозначаем бесконечную строку, где каждая была заменена ее конечным значением.s1 = s s s...sk > 1sk+1sks1_sks1[0]s1[1]s_s∞_

Выход

Первые nсимволы в виде строки.s∞

пример

Рассмотрим входы n = 30и s = ab_c_. У нас есть

s1 = ab_c_ab_c_ab_c_ab_c_ab_c_ab_c_ab_c_...

Подставляя пробелы , мы имеемs1s1

s2 = abacbab_ccab_caabbc_abcc_abacbab_cc...

Мы снова заменяем пробелы, что приводит кs1

s3 = abacbabaccabbcaabbc_abcccabacbab_cc...

Еще одна замена:

s4 = abacbabaccabbcaabbcaabcccabacbabbcc...

Из этого мы уже можем вывести первые 30 символов , которыеs∞

abacbabaccabbcaabbcaabcccabacb

Это правильный вывод.

правила

Вы можете написать полную программу или функцию. Побеждает меньшее количество байтов, и стандартные лазейки запрещены. Сбой при неправильном вводе допустим.

Тестовые случаи

0  "ab__"    -> ""
1  "ab__"    -> "a"
3  "ab__"    -> "aba"
20 "ab"      -> "abababababababababab"
20 "ab__"    -> "abababababababababab"
20 "ab_"     -> "abaabbabaabaabbabbab"
30 "ab_c_"   -> "abacbabaccabbcaabbcaabcccabacb"
50 "ab_a_cc" -> "abaabccabaaaccabbacccabcaaccabbaaccabaaaccabcaccca"
50 "abc____" -> "abcabcaabcbcaaabcbcbcabcaaababccbcbabccabcabcaaaba"

Пиф, 17

<ussC,cG\_GUQ*zQQ

Ввод должен быть представлен строкой в ​​первой строке и длиной во второй в STDIN. Например:

abc____
50

Попробуй это здесь.

Объяснение:

                             Implicit:
                             z = input()              z is the string.
                             Q = eval(input())        Q is the length.

<               Q            First Q characters of
 u         UQ*zQ             Reduce, with an initial value of z repeated Q times, 
                             on the list range(len(Q)).
                             Since the reduce function doesn't use the sequence variable H
                             this function amounts to applying the inner code Q times to
                             the initial value, where the working variable is G.
  ss                         Sum from list of tuples of strings, to tuple of strings,
                             to string.
    C,                       Zip together
      cG\_                   G split on underscores
          G                  with G.
                             This inserts a character of G between every underscore
                             separated group of G, which amounts to replacing the
                             underscores with characters of G, after summation.

APL 29 28

{a⊣(b/a)←a↑⍨+/b←'_'=a←⍺⍴⍵}⍣≡

он используется так:

fun←{a⊣(b/a)←a↑⍨+/b←'_'=a←⍺⍴⍵}⍣≡
20 fun 'ab_c_'
abacbabaccabbcaabbca

Объяснение:

a←⍺⍴⍵           makes vector long as left argument using repeated chars in right argument
a↑⍨+/b←'_'=a   takes a string from the beginning of string a (a↑⍨), long as the number of _'s in a (+/b←'_'=a)
(b/a)←          puts those chars in place of the _'s in the original vector
a⊣             and returns a
{}⍣≡            repeats function ( {} ) until results doesn't change anymore

Tryapl.org

CJam, 26 24 20 байт

4 байта сэкономлено благодаря Петру.

l~:I*{_'_/[\]zsI<}I*

Проверьте это здесь. Сначала берет строку иn вторым на STDIN.

Вы можете запустить все тестовые случаи, вставив их во входные данные такими, какие они есть (включая, -> outputесли хотите), и используя следующий тестовый набор (который меняет порядок кода):

qN/{"->"/0=S/W%S*

~:I*{_'_/[\]zsI<}I*

]oNo}/

объяснение

l~:I*{_'_/[\]zsI<}I*
l~                       "Read the input and evaluate.";
  :I                     "Store n in I for future use.";
    *                    "Repeat s n times to ensure it's long enough for the output.";
     {           }I*     "Repeat this block n times. This will always be enough passes.";
      _                  "Duplicate the string.";
       '_/               "Split the string on underscores.";
          [\]            "Swap with the other copy, putting both in an array.";
             z           "Zip the two arrays together, interleaving substrings from the split
                          copy with characters from the unsplit copy. Extraneous
                          characters from the unsplit copy just go at the end and
                          can be ignored.";
              s          "Convert the result into a string, flattening the array in the
                          process. This basically joins the two interleaved strings together.";
               I<        "Truncate to n characters.";

Результат распечатывается автоматически в конце программы.

Примечание [\]: в принципе, [запоминает текущий размер стека и ]собирает все до последнего запомненного размера в массиве. Однако, если размер массива падает ниже запоминаемого размера между ними, то начало массива корректируется соответствующим образом. Теперь вы можете подумать, что замена двух верхних элементов массива вообще не влияет на размер массива, но \фактически выдает два значения, а затем выталкивает их в обратном порядке. Это то, что толкает начало массива на два. Следовательно, [\]это самый короткий способ обернуть два верхних элемента стека в массиве. Иногда побочный эффект их сбора в обратном порядке довольно раздражает, но в данном случае это именно то, что мне нужно.

Python 3, 110 байт

n=int(input())
*b,=input()*n
a=b[:n]
while"_"in a:b,a=b[:],[x*(x!="_")or b.pop(0)for x in a]
print("".join(a))

Требуется немного больше игры в гольф, но здесь есть некоторое безумие. Читает nпотомs из STDIN.

Самое интересное, что в задании цикла мы копируем b, а затем начинаем извлекать из него bво время понимания списка . Если бы задание было наоборот, оно бы не сработало!

к, 30

{{@[x;i;:;(#i:&"_"=x)#x]}/x#y}

Ява - 162 174

Не каждый день я использую цикл do / while при игре в гольф на Java: D

Это просто повторяет и заполняет пробелы, как они приходят. Это просто продолжается до тех пор, пока _в результате не останется ничего .

char[]a(int n,char[]s){char[]o=new char[n];if(n>0)do for(int i=0,j=0;i<n;i++)if(o[i]==95|o[i]<1)o[i]=s[j++%s.length];while(new String(o).contains("_"));return o;}

С переносами строк:

char[]a(int n,char[]s){
    char[]o=new char[n];
    if(n>0)
        do
            for(int i=0,j=0;i<n;i++)
                if(o[i]==95|o[i]<1)
                    o[i]=s[j++%s.length];
        while(new String(o).contains("_"));
    return o;
}

Ява 8, 238

(n,s)->{int i=0,j=0;for(s=String.join("",java.util.Collections.nCopies(n,new String(s))).toCharArray();j<1;){for(i=0;i<n;i++){for(;s[++j]!=95&j<n;);if(j<n)s[j]=s[i];}for(j=1,i=0;i<n;)j=s[++i]==95?0:1;}return java.util.Arrays.copyOf(s,n);}

Меньше гольфа:

(Integer n, char[] s) -> {
    int i = 0, j = 0;
    for (s = String.join("", java.util.Collections.nCopies(n, new String(s))).toCharArray(); j < 1;) {
        for (i = 0; i < n; i++) {
            for (; s[j] != 95 & j < n; j++);
            if (j < n) {
                s[j] = s[i];
            }
        }
        for (j = 1, i = 0; i < n;) {
            j = s[++i] == 95 ? 0 : 1;
        }
    }
    return java.util.Arrays.copyOf(s, n);
}

Руби, 60

->n,s{eval"r=%1$p.chars;s.gsub!(?_){r.next};"*n%s*=n;s[0,n]}

Сцепляет sс собой nвремя, затем генерирует nкопии кода, который заменяет подчеркивания на s, оценивает эти копии и возвращает первые nсимволы результата. Поскольку в каждом цикле удаляется хотя бы одно подчеркивание, это гарантированно дает нам nсимволы без подчеркивания.

Python 2, 75

n,s=input()
S='';c=0
for x in s*n:b=x=='_';S+=S[c:c+b]or x;c+=b
print S[:n]

Это ожидает ввода как (30,"ab_c_") .

В Python строки не позволяют присваивать. Таким образом, заменить пробелы на нужный символ сложно. Можно обойти это путем преобразования в список и обратно, но я обнаружил, что короче просто сгенерировать выходную строку с нуля, добавляя нужные символы по одному за раз.

Создаемый вывод is S, который начинается пустым. Мы повторяем символы ввода, sскопированные много раз, чтобы смоделировать круг. Мы проверяем, является ли это пробел через логическое значение b. Мы проверяем равенствоx=='_' а не сравнение, потому что подчеркивание лежит между заглавными и строчными буквами.

Если персонаж не пустой, мы просто добавляем его S. Если оно пустое, мы добавляем следующую неиспользованную букву выходных данных S. Отслеживаем используемые буквы указателем индексаc который начинается с 0 и увеличивается каждый раз, когда мы сталкиваемся с пробелом.

В конце мы печатаем первые nсимволы полученной строкиS .

Мы должны использовать S[c:c+b]вместо более короткого, b*S[c]потому что последний выдает ошибку «за пределами», когда Sначинается пустой и cравен 0. Это никогда не имеет значения, потому что мы гарантируем, что первый символ непустой s, так что это S[c]никогда не нужно, но код не знает этого. Переключение на orкороткое замыкание также может решить эту проблему, но стоит больше символов.

Python 2, 83

Порт Pyth -to-Python решения isaacg , который использует splitи zipдля выполнения замены:

n,s=input()
s*=n
exec"s=''.join(a+b for a,b in zip(s.split('_'),s));"*n
print s[:n]

Это оказалось длиннее, потому что, удивительно, именованные методы длинные в Python. Но, возможно, это может быть улучшено путем рифления sи s.split('_')вместе более коротким способом.

Хаскелл (93) 67

Я давно не писал ни одного Haskell, так что это, вероятно, можно значительно сократить. но это было так хорошо, мы должны были сократить это и сделать это лучше!

('_':b)&(d:e)=d:b&e;(a:b)&c=a:b&c
f n s=take n$q where q=cycle s&q

Использование:

*Main> f 50 "ab_a_cc"
"abaabccabaaaccabbacccabcaaccabbaaccabaaaccabcaccca"

Партия - 425

Я проиграл?

@echo off&setLocal enableDelayedExpansion&set s=%2
if "%3"=="" (for /l %%a in (1,1,%1)do set o=!o!%s%)else set o=%3
set o=!o:~0,%1!&set l=0
:c
if defined s set/al+=1&set "s=%s:~1%"&goto c
set s=%2&set/ap=%1-1
set y=&set c=0&for /l %%a in (0,1,%p%)do set x=!o:~%%a,1!&if !x!==_ (for %%b in (!c!)do set y=!y!!s:~%%b,1!&set/ac+=1)else (set y=!y!!x!)&if !c!==%l% set c=0
if "!y:_=!"=="!y!" echo !y!&goto :EOF
%0 %1 %2 !y!

Партия имеет ограничения - я принимаю это. Например; Мне пришлось использовать цикл for, чтобы получить одну переменную в удобном для использования формате из-за ограничений синтаксиса синтаксического анализа переменных. for %%b in (!c!)do... просто существует, так что я могу использовать %%bвместо того, !c!чтобы я мог фактически выполнять манипуляции со строками !s:~%%b,1!и иметь переменные, расширяемые в нужное время.

Есть несколько довольно простых вещей, которые я мог бы сделать для игры в гольф дальше, но, вероятно, не ниже 400 байт. Скоро у меня будет еще один треск.

ECMAScript 6, 78

f=(s,n,i=0)=>[...s.repeat(n)].reduce((s,x)=>s+(x=='_'?s[i++]:x),'').slice(0,n)

Начинается с пустой строки и при каждом появлении подчеркивания заменяет его символом следующего индекса текущей строки.

Python 2 - 99 97 байт

Потому что 4-х представлений на Python недостаточно ...

n,s=input();S=s=s*n
while"_"in S:x=iter(s);S="".join(j>"_"and j or next(x)for j in S)
print S[:n]

Пример:

$ python2 t.py 
(50, "ab_a_cc")
abaabccabaaaccabbacccabcaaccabbaaccabaaaccabcaccca

ECMAScript 6, 93 91

(n,s)=>{for(x="_".repeat(n);n=0,/_/.test(x);)x=x.replace(/_/g,a=>s[n++%s.length]);return x}

Сбрил 2 персонажа из первой версии.

(n,s)=>{x="_".repeat(n);while(/_/.test(x)){n=0,x=x.replace(/_/g,a=>s[n++%s.length])}return x}

C # - 162

Я украл решение Geobits и изменил его на C #

char[]p(int n,string s){var r=new char[n];if(n>0)do for(int i=0,j=0;i<n;i++)if(r[i]=='_'||r[i]<1)r[i]=s[j++%s.Length];while(r.ToList().IndexOf('_')>=0);return r;}

1 символ лучше, так что вы можете улучшить Geobits;)