Neste desafio, o texto de letreiro falso é um texto que é mostrado parte por parte, de maneira semelhante à rolagem.

Alguns exemplos:

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

Você precisa escrever um programa ou uma função que receba duas entradas e imprima a saída conforme descrito acima. Você pode ou não gerar espaços à direita na sua saída. Este é o código-golfe, pelo que o código mais curto em bytes vence.

Se o seu programa for autônomo (ou seja, quando a execução realmente imprime as linhas) (a entrada pode ser codificada, mas fácil de alterar) e dorme um pouco entre cada linha de saída, você recebe um bônus de -10.

CJam, 12 11 bytes

1 byte salvo por Dennis.

,Sf*\f+$zN*

Estou fazendo uso de "A entrada pode ser codificada, mas fácil de alterar": isso espera que a entrada já esteja na pilha, para que você possa acrescentar "testing" 4o anterior, por exemplo.

Teste aqui.

Explicação

Observe que a transposição da saída desejada é muito mais simples:

   testing
  testing
 testing
testing

Então, só precisamos criar nlinhas, acrescentando iespaços para ide n-1baixo para cima 0. É isso que o código faz:

,            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?

Acho que o bônus "dorme um pouco entre cada linha" é um tanto vago e desonesto, mas aqui está uma versão de 19 bytes que simplesmente pára após cada linha, computando todas as permutações da matriz [0 1 .. 7]. No intérprete online, isso simplesmente leva ao resultado final sendo mostrado um pouco mais tarde, mas se você usar o interpretador Java, ele realmente imprimirá cada linha depois de "dormir um pouco":

,Sf*\f+$z{oNo8e!;}/

C, 69 bytes

magia printf!

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

Versão expandida com algumas explicações:

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

E aqui está um exemplo:

$ ./marquee stackoverflow 12

           s
          st
         sta
        stac
       pilha
      stacko
     stackov
    stackove
   empilhamento
  stackoverf
 stackoverfl
stackoverflo
tackoverflow
ackoverflow
ckoverflow
koverflow
transbordar
verflow
erflow
rflow
fluxo
baixo
ow
W

Pitão, 13 bytes

jb.:++K*dQzKQ

Experimente online: Pyth Compiler / Executor

Explicação

                 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

Python 65 63

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

Isso foi realmente usado para escrever os exemplos. Solução de linha de base.

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

  f
 fo
foo
oob
oba
bar
arz
rz
z

Javascript ( rascunho do ES7 ), 61 bytes

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>

Entradas codificadas por Javascript ( ES6 ), 47 bytes

Assumindo entradas codificadas nas variáveis s(string) e l(comprimento), ela pode ser reduzida para 47 bytes de impressão com um alerta para cada linha:

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

K, 19 bytes

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

Coloque xespaços ( x#" ") no início da sequência y. Em seguida, use o formulário "varredura de ponto fixo" do operador \para criar o conjunto de seqüências de caracteres giradas. Um ponto fixo em K para de iterar se o resultado da aplicação da função retornar um resultado repetido ou se a entrada inicial for revisitada. Uma vez ![1]que girará uma corda um passo de cada vez, ![1]\é um bom idioma para permutações cíclicas. Depois, apenas aparamos os resultados com x#'.

Uma amostra de execução:

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

J (22)

Isso acabou mais do que eu previa, mas acho que não é tão ruim.

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

Curiosidade: não são [e ]são realmente compatíveis, ou têm algo a ver um com o outro.

Julia, 75 bytes

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

Isso cria uma função sem nome que aceita uma string e um número inteiro como entrada e imprime a saída. Para chamá-lo, dê um nome, por exemplo f=(s,n)->(...).

Ungolfed + explicação:

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

Exemplos:

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     

Observe que esta solução é de 66 bytes se se nse supõe que já exista no programa.

QBasic, 56 - 10 = 46

Esta é golfed QBasic - o autoformatter vai expandir ?em PRINTe adicionar alguns espaços. Testado com QB64 , embora não deva haver nada aqui que não funcione com o DOS QBasic.

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

QBasic geralmente não é bom com operações de cadeia, mas há muito convenientemente é uma função que retorna um determinado número de espaços!

Tomando algumas liberdades com "entrada pode ser codificada", este código espera que a variável sseja DIM'd AS STRING, para evitar o $sufixo do tipo, bem como a string a ser atribuída se o número a n.

Exemplo de preâmbulo:

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

Resultado:

   s
  st
 str
stri
trin
anel
ing
ng
g

A linha em branco superior pode ser eliminada iniciando o FORloop em 2 em vez de 1.

Bônus: adicionar CLSum pouco antes NEXTde quatro bytes insignificantes transforma isso em ... uma verdadeira marca de seleção !

Eu PRINT CHR$(3)QBasic. : ^ D

Ruby, 68 , 55 bytes

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

Após uma atualização do @blutorange:

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

Resultado:

         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

Primeira submissão pedindo críticas.

Haskell, 61 59 54 bytes

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

Exemplo de uso:

*Main> putStr $ m 6 "stackoverflow"

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

*Main> 

Editar: uma linha vazia no início / fim é permitida

Bash, 109 - 10 = 99 bytes

Vejo que, no tempo que levei para escrever minha solução, fui profundamente derrotado. No entanto, passei muito tempo escrevendo para não publicá-lo ...

Além disso, possui alguns recursos exclusivos, como o tempo entre as linhas de impressão, sendo ajustável pelo usuário, com base no quanto está no diretório atual! (Também um pouco inconsistente, dependendo da sensação do seu disco)

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

Exemplo:

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

Ungolfed e comentou:

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

Eu realmente nunca tentei isso antes. Sugestões e comentários são bem-vindos!

Pure Bash, 61 bytes

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

Resultado:

$ ./marquee.sh testing 4
   t
  te
 tes
test
esti
stin
ting
ing
ng
g
$ 

Perl, 50

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

57caracteres +3para -i, -ne -l. -10caracteres para o sono.

-ié usado para a entrada numérica, que é armazenada em $^I. Basicamente, adicionamos iespaços na frente e no final da entrada e, em seguida, pesquisamos todos os icaracteres e fazemos um loop entre eles while. sayconvenientemente retorna1 qual podemos inserir sleep.

echo "testing" | perl -i4 -nlE'$c=$" x$^I;$_="$c$_$c";sleep say$1while(/(?<=(.{$^I}))/g)'

Shell POSIX, 94

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

Eu sei que parece mais perto de perl, mas isso realmente é shell!

A primeira linha adiciona os espaços iniciais necessários, apenas na primeira vez no loop. Ele define US $ 3 para indicar que o fez.

A segunda linha (nova linha incorporada NB) ocorre novamente até que a entrada seja esgotada, imprimindo o primeiro n caracteres da sequência e, em seguida, invocando-se com o primeiro caractere removido de $ 1.

Testado com Debian /bin/dash- exemplos de saídas a seguir:

./marquee "testing" 4

   t
  te
 tes
test
esti
stin
ting
ing
ng
g

./marquee "Algo um pouco mais" 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

./marquee "pequeno" 15

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

Python 2, 51 bytes / 37 bytes

Sem entrada codificada (51 bytes):

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

Ligue como f("testing", 4).

Com entrada codificada (37 bytes):

s="testing";n=4

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

Ambas as versões produzem uma linha inicial de espaços.

Python 2, (54 bytes - 10 = 44) 64 62 60 46

(Presumi que a linha para entrada codificada não adiciona à contagem de bytes.)

Ainda não vi um programa que realmente dorme entre as linhas de impressão, então criei um que sim, pois parece mais uma marquise dessa maneira. Este programa tem mais 2 bytes no Python 3.

EDIT: O programa agora faz um cálculo em vez de dormir. Eu usei ino cálculo para que o programa não o armazene como uma constante, mas precise calculá-lo sempre.

Experimente o Python 3 aqui (a substituição do Python 2 é de buggy)

i=0
while s[i-n:]:print((' '*n+s)[i:n+i]);i+=1;i**7**7

Pitão, 12 bytes

jb.:X*dyQQzQ

Demonstração.

Pitão, 17 - 10 = 7 bytes

FN.:X*dyQQzQ&.p9N

Esta versão emprega um atraso entre as impressões de linha. Isso pode ser visto no compilador de linha de comando, que você pode obter aqui .

Execute o seguinte:

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

Isso tem um atraso de cerca de 0,3 segundos antes de cada impressão. Se você preferir um atraso maior, poderá usar:

FN.:X*dyQQzQ&.pTN

Isso tem um atraso de cerca de 4 segundos.

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++));}

Versão longa:

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++));
}

O preenchimento é aplicado à sequência e, em seguida, substrings da sequência preenchida são impressos no console.

-4 bytes graças a @KevinCruijssen.

Matlab, 95

Como sempre, é uma manipulação de matrizes. O núcleo aqui é o comando spdiagsque permite criar matrizes diagonais com muita facilidade.

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

Com codificação codificada de 71 bytes (sequência esperada armazenada te número em k)

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

APL, 50 - 10 = 40 caracteres

Tenho certeza que poderia ser mais curto. 50 é a duração do programa sem as duas constantes.

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

Explicação:

                               ' '⍴⍨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

Desenvolvido para ngn APL no terminal.

Powershell - 85 83 bytes

É tarde, não vai ganhar :-) Mas pensei em colocar um Powershell por completo:

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

Cobra - 60

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

Groovy - 82

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

Lua, 79 bytes

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

C #, 112 bytes

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;};

Programa completo com método não destruído e casos de teste:

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));

        }
    }
}

Gelatina , 15 bytes - 10 = 5 ( não concorrente ?)

ḶṚ⁶ẋ;€⁹ZṄœS$€ṛ“

Experimente online!

Dorme por um segundo entre cada linha. Imprime uma nova linha à direita, se isso for aceitável.

^{yay Jelly bate Carvão}

PHP4.1, 85-10 = 75 bytes

Sim, esta é uma versão muito antiga, mas tem uma funcionalidade que eu preciso.
Você ainda pode executá-lo em versões mais recentes do PHP, mas precisa definir as variáveis ​​antes de executar o código abaixo.

Isso me ajuda a reduzir muito o tamanho do meu código!

É realmente básico:

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

Corri para o bônus devido a isso, citando OP:

Se o seu programa for autônomo (ou seja, quando a execução realmente imprime as linhas) (a entrada pode ser codificada, mas fácil de alterar) e dorme um pouco entre cada linha de saída, você recebe um bônus de -10.

Como você pode obviamente ver, ele dorme.

Isso pressupõe que você tenha register_globalsativado por padrão, que eram as configurações padrão para esta versão.

Você pode testar facilmente no seu navegador, com mínimo algumas mudanças:

//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}

O código acima é um poliglota e você pode executar no seu navegador ou em um intérprete PHP. Não devo receber um prêmio por isso? Um biscoito, talvez?

Lista de alterações:

• Removido o sleep(1)neste teste
• Criou 2 versões da função concat
  O objetivo é superar as diferenças de PHP e JS na concatenação de strings.
• Em vez de um espaço, a -é usado para preencher o espaço
• Em vez de echo, printfé usado em vez (limitação do PHP)
• Em vez disso, ou uma nova linha 'real', <br>é usada

J , 15 14 bytes

,.~/@(' '&,~<)

Experimente online!

APL (Dyalog) , 17 bytes

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

Experimente online!

(o programa assume ⎕IO←0 padrão em muitas máquinas)

Explicação

⍳⎕               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