En este desafío, el texto falso de la marquesina es texto que se muestra parte por parte, en forma de desplazamiento.

Algunos ejemplos:

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

Tiene que escribir un programa o una función que tome dos entradas e imprima la salida como se describió anteriormente. Puede o no generar espacios finales en su salida. Este es el código de golf, por lo que el código más corto en bytes gana.

Si su programa es independiente (es decir, cuando se ejecuta realmente imprime las líneas) (la entrada puede ser codificada pero fácil de cambiar) y duerme un poco entre cada línea de salida, obtiene un bono de -10.

CJam, 12 11 bytes

1 byte guardado por Dennis.

,Sf*\f+$zN*

Estoy haciendo uso de "La entrada puede ser codificada pero fácil de cambiar": esto espera que la entrada ya esté en la pila, por lo que puede anteponerse "testing" 4a lo anterior, por ejemplo.

Pruébalo aquí.

Explicación

Tenga en cuenta que la transposición de la salida deseada es mucho más simple:

   testing
  testing
 testing
testing

Así que solo necesitamos crear nlíneas, anteponiendoi espacios idesde n-1abajo hacia abajo 0. Eso es lo que hace el código:

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

Encuentro el bono "duerme un poco entre cada línea" un poco vago y poco fiable, pero aquí hay una versión de 19 bytes que simplemente se detiene después de cada línea al calcular todas las permutaciones de la matriz [0 1 .. 7]. En el intérprete en línea, esto simplemente lleva a que el resultado final se muestre un poco más tarde, pero si usa el intérprete de Java, esto realmente imprimirá cada línea después de "dormir un poco":

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

C, 69 bytes

printf magic!

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

Versión ampliada con alguna explicación:

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

Y aquí hay un ejemplo:

$ ./marquee stackoverflow 12

           s
          S t
         sta
        stac
       apilar
      stacko
     stackov
    pila
   apilamiento
  stackoverf
 stackoverfl
stackoverflo
tackoverflow
ackoverflow
ckoverflow
koverflow
Desbordamiento
verflow
erflow
rflow
fluir
bajo
Ay
w

Pyth, 13 bytes

jb.:++K*dQzKQ

Pruébelo en línea: Pyth Compiler / Executor

Explicación

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

En realidad, esto se usó para escribir los ejemplos. Solución basal.

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

  f
 fo
foo
oob
oba
bar
arz
rz
z

Javascript ( borrador 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 de Javascript ( ES6 ), 47 bytes

Suponiendo entradas codificadas en las variables s(cadena) y l(longitud), se puede reducir a 47 bytes de impresión con una alerta para cada línea:

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

K, 19 bytes

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

Agregue xespacios ( x#" ") al comienzo de la cadena y. Luego use la forma de "exploración de punto fijo" del operador \para crear el conjunto de cadenas rotadas. Un punto fijo en K deja de iterar si el resultado de aplicar la función devuelve un resultado repetido o si se revisa la entrada inicial. Dado ![1]que rotará una cadena un paso a la vez, ![1]\es un buen modismo para las permutaciones cíclicas. Luego simplemente recortamos los resultados con x#'.

Una muestra de ejecución:

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

J (22)

Esto terminó más tiempo de lo que esperaba, pero supongo que no es tan malo.

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

Dato curioso: ninguno de los [y en ]realidad coinciden, o tienen algo que ver entre sí.

Julia, 75 bytes

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

Esto crea una función sin nombre que acepta una cadena y un entero como entrada e imprime la salida. Para llamarlo, dale un nombre, por ejemplo f=(s,n)->(...).

Ungolfed + explicació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

Ejemplos:

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     

Tenga en cuenta que esta solución tiene 66 bytes si sy nse supone que ya existe en el programa.

QBasic, 56-10 = 46

Esto se jugó golf QBasic - la autoformatter se expandirá ?hacia PRINTy añadir algunos espacios. Probado con QB64 , aunque no debería haber nada aquí que no funcione con DOS QBasic.

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

QBasic generalmente no es bueno con las operaciones de cadena, pero muy convenientemente hay una función que devuelve un número dado de espacios.

Tomando algunas libertades con "input puede estar codificado", este código espera que la variable ssea DIM'd AS STRING, para evitar el $sufijo de tipo, así como la cadena a la que se asigna sy el número n.

Preámbulo de ejemplo:

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

Salida:

   s
  S t
 str
Stri
trin
anillo
En g
ng
sol

La fila en blanco superior puede eliminarse iniciando el FORciclo en 2 en lugar de 1.

Bonificación: Agregar CLSjusto antes NEXTde un mísero cuatro bytes convierte esto en ... ¡una verdadera marquesina !

Yo 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]}

Después de una actualización de @blutorange:

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

Salida:

         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

Primera presentación para pedir críticas.

Haskell, 61 59 54 bytes

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

Ejemplo 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: se permite una línea vacía al principio / al final

Bash, 109-10 = 99 bytes

Veo que en el tiempo que me llevó escribir mi solución, me han golpeado profundamente. Sin embargo, pasé demasiado tiempo escribiéndolo para no publicarlo ...

Además de eso, tiene algunas características únicas, como que el tiempo entre la impresión de líneas sea ajustable por el usuario en función de cuánto hay en el directorio actual. (También algo inconsistente, dependiendo de cómo se sienta su 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

Ejemplo:

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 y comentó:

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

Realmente nunca he intentado esto antes. Sugerencias y comentarios bienvenidos!

Pure Bash, 61 bytes

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

Salida:

$ ./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)

57personajes +3para -i,-n y -l. -10personajes para el sueño

-ise usa para la entrada numérica, que se almacena en $^I. Básicamente, agregamos iespacios al frente y al final de la entrada, y luego buscamos todos los icaracteres y los recorremos con ellos while. sayconvenientemente devuelve 1lo que podemos ingresar sleep.

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

POSIX shell, 94

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

Sé que se parece más a Perl, ¡pero esto realmente es una concha!

La primera línea agrega los espacios iniciales necesarios, solo la primera vez a través del ciclo. Establece $ 3 para indicar que lo ha hecho.

La segunda línea (nueva línea incrustada NB) vuelve a aparecer hasta que se agota la entrada, imprimiendo la primera n caracteres de la cadena y luego se invoca con el primer carácter eliminado de $ 1.

Probado con Debian /bin/dash- a continuación se muestran ejemplos de resultados:

./marquee "prueba" 4

   t
  te
 tes
test
esti
stin
ting
ing
ng
g

./marquee "Algo un poco más largo" 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 "pequeño" 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

Sin entrada codificada (51 bytes):

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

Llama como f("testing", 4).

Con entrada codificada (37 bytes):

s="testing";n=4

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

Ambas versiones generan una línea inicial de espacios.

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

(Supuse que la línea para la entrada codificada no se suma al recuento de bytes).

Todavía no vi un programa que realmente duerma entre líneas de impresión, así que hice uno que sí, ya que se parece más a una marquesina de esa manera. Este programa tiene 2 bytes más en Python 3.

EDITAR: El programa ahora hace un cálculo en lugar de dormir. Lo usé ien el cálculo para que el programa no lo almacene como una constante, sino que debe calcularlo cada vez.

Pruebe el Python 3 aquí (la respuesta de Python 2 tiene errores)

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

Pyth, 12 bytes

jb.:X*dyQQzQ

Demostración.

Pyth, 17-10 = 7 bytes

FN.:X*dyQQzQ&.p9N

Esta versión emplea un retraso entre las impresiones de línea. Esto se puede ver en el compilador de línea de comandos, que puede obtener aquí .

Ejecute lo siguiente:

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

Esto tiene un retraso de aproximadamente 0.3 segundos antes de cada impresión. Si prefiere un retraso más largo, puede usar:

FN.:X*dyQQzQ&.pTN

Esto tiene un retraso de aproximadamente 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++));}

Versión larga:

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

El relleno se aplica a la cadena, y luego las subcadenas de la cadena se imprimen en la consola.

-4 bytes gracias a @KevinCruijssen.

Matlab, 95

Como siempre, es una manipulación de matrices. El núcleo aquí es el comando spdiagsque le permite crear matrices diagonales muy fácilmente.

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

Con codificación fija de 71 bytes (cadena esperada almacenada ty número 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

Estoy seguro de que podría ser más corto. 50 es la duración del programa sin las dos constantes.

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

Explicación:

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

Desarrollado para ngn APL en la terminal.

Powershell - 85 83 bytes

Es tarde, no va a ganar :-) Pero pensé en tirar un Powershell para completar:

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]

Maravilloso - 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 con método no protegido y casos de prueba:

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

        }
    }
}

Jelly , 15 bytes - 10 = 5 (¿ no compite ?)

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

Pruébalo en línea!

Duerme por un segundo entre cada línea. Imprime una nueva línea final, si eso es aceptable.

^{yay Jelly beats Charcoal}

PHP4.1, 85-10 = 75 bytes

Sí, esta es una versión muy antigua, pero tiene una funcionalidad que necesito.
Todavía puede ejecutarlo en cualquier versión más reciente de PHP, pero debe configurar las variables usted mismo antes de ejecutar el código a continuación.

¡Eso me ayuda a reducir mucho el tamaño de mi código!

Es realmente básico:

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

Corrí por la bonificación debido a esto, citando a OP:

Si su programa es independiente (es decir, cuando se ejecuta realmente imprime las líneas) (la entrada puede ser codificada pero fácil de cambiar) y duerme un poco entre cada línea de salida, obtiene un bono de -10.

Como obviamente puedes ver, tiene un sueño.

Esto supone que ha register_globalshabilitado de forma predeterminada, que eran las configuraciones predeterminadas para esta versión.

Puede probar fácilmente en su navegador, con mínimo algunos cambios:

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

El código anterior es un políglota y puede ejecutarse en su navegador o en un intérprete PHP. ¿No debería obtener un premio por esto? ¿Una galleta, tal vez?

Lista de cambios:

• Eliminado sleep(1)en esta prueba
• Creé 2 versiones de la función concat
  El objetivo es superar las diferencias de PHP y JS en cadenas de concatenación.
• En lugar de un espacio, -se usa a para llenar el espacio
• En lugar de echo, printfse utiliza en su lugar (limitación de PHP)
• En cambio, o una nueva línea "real", <br>se utiliza en su lugar

J , 15 14 bytes

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

Pruébalo en línea!

APL (Dyalog) , 17 bytes

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

Pruébalo en línea!

(el programa asume ⎕IO←0cuál es el valor predeterminado en muchas máquinas)

Explicación

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