假字幕文本

46

在此挑战中，伪字幕文本是以滚动方式逐部分显示的文本。

一些例子：

testing 4

   t
  te
 tes
test
esti
stin
ting
ing
ng
g


hello 2

 h
he
el
ll
lo
o


foobarz 3

  f
 fo
foo
oob
oba
bar
arz
rz
z


Something a bit longer 10

         S
        So
       Som
      Some
     Somet
    Someth
   Somethi
  Somethin
 Something
Something 
omething a
mething a 
ething a b
thing a bi
hing a bit
ing a bit 
ng a bit l
g a bit lo
 a bit lon
a bit long
 bit longe
bit longer
it longer
t longer
 longer
longer
onger
nger
ger
er
r


small 15

              s
             sm
            sma
           smal
          small
         small
        small
       small
      small
     small
    small
   small
  small
 small
small
mall
all
ll
l


aaa 3

  a
 aa
aaa
aa
a


brace yourself 6

     b
    br
   bra
  brac
 brace
brace 
race y
ace yo
ce you
e your
 yours
yourse
oursel
urself
rself
self
elf
lf
f

您必须编写一个接受两个输入并如上所述打印输出的程序或函数。您可能会或可能不会在输出中输出尾随空格。这是代码高尔夫球，因此以字节为单位的最短代码获胜。

如果您的程序是独立的（即在运行时实际打印行）（输入可以进行硬编码但易于更改）并且在输出的每一行之间保持一点睡眠，那么您将获得-10的奖励。

code-golf  string 
— 卡里多克
source
“包含输出”是什么意思？
— Optimizer
1
另外，我们是否必须打印仅是空格的第一行和最后一行？
— 优化器
2
灵感来自这个？
— Spikatrix
1
开头似乎只能有一个空行。最后还有一条空行怎么样？
— nimi
2
由于您是在谈论“仅可见输出”，因此我们可以假设输入将只能是可打印的ASCII吗？（字符代码0x20到0x7E）
— 马丁·恩德

Answers:

24

CJam，12 11个字节

Dennis保存了1个字节。

,Sf*\f+$zN*

我正在使用“输入可以是硬编码的，但很容易更改”：这期望输入已经在堆栈中，因此您可以"testing" 4在上面添加示例。

在这里测试。

说明

注意，所需输出的转置要简单得多：

   testing
  testing
 testing
testing

因此，我们只需要创建n行，并在i空格之间添加i从n-1向下到的行即可0。这就是代码的作用：

,            e# Turn n into a range [0 1 .. n-1]
 Sf*         e# Turn each i into a string of i spaces.
    \f+      e# Swap this array with the input string and append it to each of the
             e# strings of spaces.
       $     e# Sort the array to have the string with n-1 spaces first.
        z    e# Transpose the grid.
         N*  e# Join the lines with newline characters.

19-10 = 9？

我发现“在每行之间稍稍睡一下”的奖励有点模糊和晦涩，但这是一个19字节的版本，通过计算数组的所有排列，仅在每行之后停顿[0 1 .. 7]。在在线解释器中，这只会导致最终结果稍后显示，但是如果您使用Java解释器，则实际上将在“稍睡一会”之后打印每一行：

,Sf*\f+$z{oNo8e!;}/
— 马丁·恩德
source
很好用z。假设输入是可打印的ASCII，则可以替换W%为$。
— 丹尼斯
@丹尼斯哦，我喜欢。我已要求OP对此进行澄清。（也就是说，我z一直都在使用基于网格的ascii挑战。）
— Martin Ender 2015年
15

C，69字节

printf魔术！

f(s,n,i)char*s;{for(i=n;*s;i?i--:s++)printf("%*s%.*s\n",i,"",n-i,s);}

扩展版本并提供一些解释：

f(s,n,i)char*s;{       /* s is the string, n is the width of the grid. */
  for(i=n;             /* i is the number of preceding spaces. */
      *s;              /* Stop once we reach the end of the string. */
      i?i--:s++)       /* Decrease the number of spaces, and when there's 
                          none left start truncating the string itself. */
  printf("%*s          /* The first argument is the minimum width to print the 
                          string (left padded with spaces) and the second 
                          argument is the string to print. We use the empty 
                          string just to print the i spaces. */
    %.*s              /* The third argument is the maximum number of 
                         characters from the string (which is the fourth 
                         argument) to print. */
    \n",i,"",n-i,s);
}

这是一个例子：

$ ./marquee stackoverflow 12

           s
          圣
         sta
        stac
       堆
      Stacko
     Stackov
    堆栈
   叠加
  stackoverf
 stackoverfl
stackoverflo
粘性溢出
确认溢出
ckoverflow
Koverflow
溢出
顺流
流
流
流
低
ow
w
— CL-
source
14

Pyth，13个字节

jb.:++K*dQzKQ

在线尝试：Pyth编译器/执行器

说明

                 implicit: z = input string, Q = input number
      K*dQ       K = " " * Q
    ++K   zK     K + z + K
  .:        Q    all substrings of length Q
jb               join by newlines and print
— 雅库比
source
6

蟒蛇65 63

s=lambda t,s:'\n'.join((' '*s+t)[i:s+i]for i in range(len(t)+s))

这实际上是用来编写示例的。基准解决方案。

>>> print(s("foobarz", 3))

  f
 fo
foo
oob
oba
bar
arz
rz
z
— 卡里多克
source
2
我没有测试它，但你应该能够删除里面的方括号join
— undergroundmonorail
@undergroundmonorail右
— Caridorc
6

Javascript（ES7 Draft），61字节

f=(s,l)=>[x.substr(i,l)for(i in x=' '.repeat(l)+s)].join(`
`)
<input id="str" value="Some String" />
<input id="num" value="5" />
<button onclick="out.innerHTML=f(str.value, +num.value)">Run</button>
<br /><pre id="out"></pre>
展开摘要

Javascript（ES6）硬编码输入，47字节

假设在变量s（字符串）和l（长度）中使用硬编码输入，则可以将其减少为47字节打印，并且每行都有一个警报：

for(i in x=' '.repeat(l)+s)alert(x.substr(i,l))
— nderscore
source
5

K，19个字节

{x#'![1]\(x#" "),y}

粘性x空间（x#" "）到字符串的开头y。然后使用运算符的“定点扫描”形式\创建一组旋转的字符串。如果应用函数的结果返回重复的结果或重新访问了初始输入，则K中的定点将停止迭代。由于![1]将一次旋转一个字符串，因此![1]\是循环排列的一个好习惯。然后我们只用修剪结果x#'。

运行示例：

  {x#'![1]\(x#" "),y}[4;"some text"]
("    "
 "   s"
 "  so"
 " som"
 "some"
 "ome "
 "me t"
 "e te"
 " tex"
 "text"
 "ext "
 "xt  "
 "t   ")
— 约翰
source
5

J（22）

结束时间比我预期的要长，但是我想还算不错。

[{."0 1[:]\.(' '#~[),]

有趣的事实：并非[与]实际匹配，或与彼此有任何关系。

— ɐɔıʇǝɥʇuʎs
source
经过3个小更改：[{."1]]\.@,~' '#~[（18个字节）。
— randomra'5
5

朱莉娅，75个字节

(s,n)->(n-=1;print(join([(" "^n*s*" "^n)[i:n+i]for i=1:length(s)+n],"\n")))

这将创建一个未命名函数，该函数接受字符串和整数作为输入并输出输出。要给它起个名字，例如f=(s,n)->(...)。

取消+说明：

function f(s, n)
    # Decrement n by 1
    n -= 1

    # Construct the lines as an array using comprehension by repeatedly
    # extracting subsets of the input string padded with spaces
    lines = [(" "^n * s * " "^n)[i:n+i] for i = 1:length(s)+n]

    # Print the array elements separated by a newline
    print(join(lines, "\n"))
end

例子：

julia> f("banana", 3)
  b
 ba
ban
ana
nan
ana
na 
a

julia> f("Julia", 6)
     J
    Ju
   Jul
  Juli
 Julia
Julia 
ulia  
lia   
ia    
a

请注意，如果s和n假定已存在于程序中，则此解决方案为66字节。

— 亚历克斯·A
source
5

QBasic，56-10 = 46

这是golfed QBasic中-在autoformatter将扩大?到PRINT添加一些空间。经过QB64的测试，尽管这里不应该有任何不适用于DOS QBasic的东西。

s=SPACE$(n)+s
FOR i=1TO LEN(s)
?MID$(s,i,n)
SLEEP 1
NEXT

QBasic通常不适用于字符串操作，但是非常方便的是有一个函数可以返回给定数量的空格！

采取一些“输入可能是硬编码”的自由方式，该代码希望变量s为DIM'd AS STRING，以避免$类型后缀以及分配给字符串和分配给to s的数字n。

前言示例：

DIM s AS STRING
s="string"
n=4

输出：

   s
  圣
 力量
斯特里
特林
环
ing
ng
G

通过从FOR2（而不是1）开始循环，可以消除顶部空白行。

奖励：添加CLS合适的前NEXT一个微不足道的四个字节变成一...这真实的帐篷！

选框

我PRINT CHR$(3)QBasic。：^ D

— DLosc
source
我应该再次尝试QBasic ...这是我第一次学到的东西
— 加拿大卢克·雷斯特内斯·莫尼卡
5

Ruby，68个，55个字节

a=" "*$*[1].to_i+$*[0]+" ";a.size.times{|b|puts a[b...b+$*[1].to_i]}

从@blutorange更新后：

a=" "*(z=$*[1].to_i)+$*[0];a.size.times{|b|puts a[b,z]}

输出：

         S
        So
       Som
      Some
     Somet
    Someth
   Somethi
  Somethin
 Something
Something 
omething a
mething a 
ething a b
thing a bi
hing a bit
ing a bit 
ng a bit l
g a bit lo
 a bit lon
a bit long
 bit longe
bit longer
it longer 
t longer 
 longer 
longer 
onger 
nger 
ger 
er 
r

ruby marquee.rb "Something a bit longer" 10

第一次提交，所以要求批评。

— 迪基男孩
source
1
使用红宝石快捷方式，对我来说看起来做得不错。不过，最后一个空格似乎并不是必需的（“仅可见输出很重要”），您可以使用一个临时变量来保存一些字节：a=" "*(z=$*[1].to_i)+$*[0];a.size.times{|b|puts a[b,z]}
— blutorange
@blutorange感谢您的反馈！
— DickieBoy
别客气。如有需要，请随时编辑答案；）
— blutorange
4

Haskell，61 59 54字节

m n=unlines.scanr((take n.).(:))[].(replicate n ' '++)

用法示例：

*Main> putStr $ m 6 "stackoverflow"

     s
    st
   sta
  stac
 stack
stacko
tackov
ackove
ckover
koverf
overfl
verflo
erflow
rflow
flow
low
ow
w

*Main>

编辑：开头/结尾的空行是允许的

— 妮米
source
4

Bash 109-10 = 99字节

我看到在花时间写我的解决方案的过程中，我遭到了殴打。不过，我花了太长时间写它，以至于不予发表。

除此之外，它还具有一些独特的功能，例如用户可以根据当前目录中的行数来调整行之间的打印时间！（也有些不一致，具体取决于磁盘的感觉）

l=${#1};s=$1;for j in `seq 1 $2`;do s=" $s";done;for i in `seq 0 $((l+$2))`;do echo "${s:i:$2}";find 1>2;done

例：

cd <some directory in which you own everything recursively>
Marquee.sh "Test Case" 4

   T
  Te
 Tes
Test
est 
st C
t Ca
 Cas
Case
ase
se
e

取消评论并评论：

l=${#1} #Length of the incoming string
s=$1 #Can't reassign to the parameter variables, so give it another name
for j in `seq 1 $2`; do
    s=" $s" # Put on the padding spaces
done

for i in `seq 0 $((l+$2))`; do
    #Cut the string and print it. I wish I could lose "padding" that easily!
    echo "${s:i:$2}" #Format is ${string:index:length}, so always the same
    # length, with the index moving into the string as the loop advances
    find 1>2  #Wait "a bit". From ~/, about 6 minutes per line on my junky 
    # computer with a huge home directory. Probably in the <1 sec range for
    # most people.
    #This actually has the same character count as sleep(X), but is much
    # more fun!
done

我以前从未真正尝试过。欢迎提出建议和意见！

— 松波
source
4

纯Bash，61个字节

printf -vs %$2s"$1"
for((;++i<${#1}+$2;)){
echo "${s:i:$2}"
}

输出：

$ ./marquee.sh testing 4
   t
  te
 tes
test
esti
stin
ting
ing
ng
g
$
— 数字创伤
source
我猜我不理解“纯” Bash的区别，所以这个建议可能没有什么用，但是sleep（1）是8个字符，可以给您-10（并且是GNU Core Util）
— Sompom
3

Perl，50岁

$c=$" x$^I;$_="$c$_$c";sleep say$1while(/(?<=(.{$^I}))/g)

57字符+3的-i，-n和-l。-10睡觉的人物。

-i用于数字输入，存储在中$^I。基本上，我们i在输入的开头和结尾添加空格，然后搜索每个i字符并使用循环遍历它们while。say方便地返回1，我们可以输入sleep。

echo "testing" | perl -i4 -nlE'$c=$" x$^I;$_="$c$_$c";sleep say$1while(/(?<=(.{$^I}))/g)'
— hmatt1
source
我知道这已经很老了，但是它只是跳回到了首页上，因此我可以将其缩小一些s/^|$/$"x$^I/eg;sleep say$1 while s/.(.{$^I})/$1/。您也可以丢掉该-l标志，但是如果您通过以下方式运行，我认为您需要计算5 -i -n（因为-i这不是默认标志）echo -n "testing" | perl -i4 -nE'...'。虽然应该还是降至44！
— Dom Hastings
@DomHastings感谢Dom！
— 做得好
3

POSIX外壳，94

[ $3 ]||set "`printf "%${2}s"`$1" $2 t
[ "$1" ]&&printf "%-.${2}s" "$1" "
"&&$0 "${1#?}" $2 t

我知道它看起来更接近perl，但这确实是shell！

第一行仅在第一次通过循环时添加必要的前导空格。它设置$ 3表示已这样做。

第二行（NB内嵌的换行符）重复进行直到输入耗尽，然后打印字符串的前n个字符，然后调用自身并将第一个字符从$ 1中删除。

经过Debian测试/bin/dash-示例输出如下：

./marquee“测试” 4

   t
  te
 tes
test
esti
stin
ting
ing
ng
g

./marquee“有点长” 10

         S
        So
       Som
      Some
     Somet
    Someth
   Somethi
  Somethin
 Something
Something 
omething a
mething a 
ething a b
thing a bi
hing a bit
ing a bit 
ng a bit l
g a bit lo
 a bit lon
a bit long
 bit longe
bit longer
it longer
t longer
 longer
longer
onger
nger
ger
er
r

./选取框“小” 15

              s
             sm
            sma
           smal
          small
         small
        small
       small
      small
     small
    small
   small
  small
 small
small
mall
all
ll
l
— 托比·斯皮特（Toby Speight）
source
我可以加9个字符以获得-10奖金！[“ $ 1”] && printf“％-。$ {2} s”“ $ 1”“” && sleep 1 && $ 0“ $ {1＃？}” $ 2 t
— Toby Speight 2015年
3

Python 2，51个字节/ 37个字节

没有硬编码输入（51字节）：

def f(s,n):
 s=" "*n+s
 while s:print s[:n];s=s[1:]

打电话喜欢f("testing", 4)。

使用硬编码输入（37字节）：

s="testing";n=4

s=" "*n+s
while s:print s[:n];s=s[1:]

两种版本均输出初始空格行。

— Sp3000
source
3

Python 2，（54个字节-10 = 44） 64 62 60 46

（我假设用于硬编码输入的行不会增加字节数。）

我还没有看到一个实际上可以在打印行之间休眠的程序，所以我做了一个可以运行的程序，因为它看起来更像是一个字幕。该程序在Python 3中还有2个字节。

编辑：该程序现在执行计算而不是休眠。我i在计算中使用了该程序，因此程序不会将其存储为常量，而是每次都必须对其进行计算。

在这里尝试使用Python 3（Python 2代表错误）

i=0
while s[i-n:]:print((' '*n+s)[i:n+i]);i+=1;i**7**7
— mbomb007
source
也许time.sleep可以使用一些冗长的计算，而不是使用？另外，使用while循环会短一些：i=0\nwhile s[i-n:]:print(' '*n+s)[i:n+i];i+=1
— xnor 2015年
@xnor幂运算几次可以很好地进行计算。
— mbomb007
@ mbomb007我认为您不需要存储计算值就可以使python实际执行它（因此您可以保存“ q =”）。同样，x ^ 7 ^ 7在数学上等价于x ^ 49，尽管python似乎对我来说稍快一些。您可以这样保存一些字符。
— Sompom
@Sompom在repl中尝试一下。如果将表达式合并为一个指数，它将完全消除时间延迟。但是我会删除q=。谢谢。
— mbomb007
@Sompom指数是右关联的，因此实际上是i**(7**7)
— Sp3000
3

Pyth，12个字节

jb.:X*dyQQzQ

示范。

Pyth，17-10 = 7个字节

FN.:X*dyQQzQ&.p9N

此版本在行打印之间使用了延迟。这可以在命令行编译器上看到，您可以在此处获得。

运行以下命令：

pyth -c 'FN.:X*dyQQzQ&.p9N' <<< 'testing
4'

每次打印前大约有0.3秒的延迟。如果您希望延迟更长，可以使用：

FN.:X*dyQQzQ&.pTN

这大约有4秒的延迟。

— 伊萨格
source
3

Java中，133 119 115

int i;void f(String s,int n){for(;++i<n;)s=" "+s+" ";for(;i<=s.length();)System.out.println(s.substring(i-n,i++));}

长版：

int i;
void f(String s, int n) {
    for(; ++i < n;)
        s = " " + s + " ";
    for(; i<=s.length();)
        System.out.println(s.substring(i-n, i++));
}

将填充应用于字符串，然后将填充字符串的子字符串打印到控制台。

-4个字节，感谢@KevinCruijssen。

— TNT
source
我知道已经过去一年多了，但是您可以在第二个循环中打高尔夫：( -3个字节）for(;i<= s.length();System.out.println(s.substring(i-n,i++)));
— 凯文·克鲁伊森
1
并不意味着它无法得到改善。：） 谢谢。
— TNT
2

Matlab，95岁

与往常一样，它是对矩阵的操纵。该命令的核心是spdiags使您可以非常轻松地创建对角矩阵的命令。

t=input('');
n=numel(t);
k=input('');
flipud(char(full(spdiags(repmat(t,n+k-1,1),1-n:0,n+k-1,k))))

使用71字节的硬编码（预期的字符串存储在中t，数字存储在中k）

n=numel(t);flipud(char(full(spdiags(repmat(t,n+k-1,1),1-n:0,n+k-1,k))))
— 瑕疵
source
2

APL，50-10 = 40个字符

我相信它可能会更短。50是没有两个常量的程序的长度。

{⍵≡⍬:⍬⋄⎕←↑⍵⋄⎕DL 99⋄∇1↓⍵}⊂[0]⊖s⍴⍨n,¯1+⍴s←'brace yourself',' '⍴⍨n←6

说明：

                               ' '⍴⍨n←6   call the number 'n' and make n spaces
            s←'brace yourself',           append them to the string and call it 's'
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
                             s⍴⍨n,¯1+⍴s   make a len(s)-1 by n matrix by repeating s 
                        ⊂[0]⊖             reflect the matrix and extract the columns
{                      }                  pass the list of columns to this function
 ⍵≡⍬:⍬⋄                                   return if the list is empty
       ⎕←↑⍵⋄                              print the first column (as a row)
            ⎕DL 99⋄                       wait for 99ms
                   ∇1↓⍵                   recurse with the rest of the columns

为终端上的ngn APL开发。

— 托比亚
source
2

Powershell- 85 83字节

已经很晚了，它不会赢:-)但是我想我会为了完整性而投入一个Powershell：

function m($s,$n){1..$($n+$s.length)|%{-join(" "*$n+$s+" "*$n)[$_-1..$($n+$_-1)]}}

— 克里斯·J
source
1

眼镜蛇-60

def f(n,s)
    s=' '.repeat(n)+s
    while''<s,print (s=s[1:])[:n]
— 巨大
source
1

Groovy-82

n=args[1]as int;t=" "*n+args[0]+" "*n;(0..t.size()-n).each{println t[it..it+n-1]}
— dbramwell
source
1

Lua，79个字节

r=io.read;t=r()w=r()s=" "t=s:rep(w)..t;for i=1,t:len()do print(t:sub(i,i+w))end
— 胡扯
source
1

C＃，112字节

s=>n=>{var r=new string(' ',n-1);s=r+s+r;r="";for(int i=0;i<s.Length-n+1;)r+=s.Substring(i++,n)+"\n";return r;};

完整的程序，包含未使用的方法和测试用例：

using System;

namespace FakeMarqueeText
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string,Func<int,string>>f= s=>n=>
            {
                var r=new string(' ',n-1);
                s=r+s+r;
                r="";
                for(int i=0;i<s.Length-n+1;)
                    r+=s.Substring(i++,n)+"\n";

                return r;
            };

            // test cases:
            Console.WriteLine(f("testing")(4));
            Console.WriteLine(f("hello")(2));
            Console.WriteLine(f("foobarz")(3));
            Console.WriteLine(f("Something a bit longer")(10));
            Console.WriteLine(f("small")(15));
            Console.WriteLine(f("aaa")(3));
            Console.WriteLine(f("brace yourself")(6));

        }
    }
}
— 阿德里安普
source
1

PHP4.1，85-10 = 75字节

是的，这是一个非常旧的版本，但是它具有我需要的功能。
您仍然可以在任何较新的PHP版本中运行它，但是在运行下面的代码之前，需要自己设置变量。

这可以帮助我减少很多代码！

这真的很基本：

<?for($s=str_repeat(' ',$n).$s;$i++<strlen($s)+$n;sleep(1))echo substr($s,$i,$n),'
';

因此，我引用了OP来争取奖金：

如果您的程序是独立的（即在运行时实际打印行）（输入可以进行硬编码但易于更改）并且在输出的每一行之间保持一点睡眠，那么您将获得-10的奖励。

如您所见，它已经入睡了。

假定您已register_globals默认启用，这是该版本的默认设置。

您可以轻松地在浏览器中进行测试， 最小的 一些变化：

//detects if it is running in js or php
//true for js, false for php
if('\0'=="\0")
{
	function strlen($s){
		return $s.length;
	}
	
	function str_repeat($s,$n){
		return Array($n+1).join($s);
	}
	
	function substr($s,$n,$m){
		return $s.substr($n,$m);
	}
	
	function printf($s){
		document.write($s);
	}
	
	function concat($a,$b){
		return $a+$b;
	}
}
else
{
	function concat($a,$b){
		return $a.$b;
	}
}

//sets the variables, not required for PHP if you pass the values by GET or POST
$i=0;
$s='example';
$n=6;



for($s=concat(str_repeat('-',$n),$s);$i++<strlen($s)+$n;)printf(concat(substr($s,$i,$n),'<br>'));
*{font-family:monospace}
展开摘要

上面的代码是多语言的，您可以在浏览器或PHP解释器中运行。我不应该为此获奖吗？饼干吗？

变更清单：

  • sleep(1)在此测试中删除了
  • 创建了2个版本的函数concat
    ，目标是克服PHP和JS在连接字符串方面的差异。
  • 代替空格，使用a -填充空格
  • 代替echo，而是printf使用（PHP限制）
  • 而是使用“真实”换行符<br>代替
— 伊斯梅尔·米格尔（Ismael Miguel）
source
1

APL（Dyalog），17个字节

⌽⍉↑(⎕,⍨' '/⍨⊢)¨⍳⎕

在线尝试！

（程序假定⎕IO←0这是许多计算机上的默认设置）

说明

⍳⎕               Create a range 0 .. input-1
¨                For each element in this range do:
 ' '/⍨⊢           A space duplicated right argument (which is the element in  the range) times
 ⎕,⍨              Concatenated with the input string to its right
⌽⍉               Transpose and reflect horizontally
— 克里特希·里索斯（Kritixi Lithos）
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.