Dans ce défi, le faux texte de sélection est un texte affiché partie par partie, à la manière d'un défilement.

Quelques exemples:

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

Vous devez écrire un programme ou une fonction qui prend deux entrées et imprime la sortie comme décrit ci-dessus. Vous pouvez ou non produire des espaces de fin dans votre sortie. C'est le code-golf, donc le code le plus court en octets gagne.

Si votre programme est autonome (c'est-à-dire lorsqu'il est exécuté, il imprime réellement les lignes) (l'entrée peut être codée en dur mais facile à modifier) ​​et qu'il dort un peu entre chaque ligne de sortie, vous obtenez un bonus de -10.

CJam, 12 à 11 octets

1 octet enregistré par Dennis.

,Sf*\f+$zN*

Je me sers de "L'entrée peut être codée en dur mais facile à modifier": cela suppose que l'entrée soit déjà sur la pile, de sorte que vous pouvez ajouter une valeur "testing" 4à celle ci-dessus, par exemple.

Testez-le ici.

Explication

Notez que la transposition de la sortie souhaitée est beaucoup plus simple:

   testing
  testing
 testing
testing

Donc , nous avons juste besoin de créer des nlignes, préfixer iespaces pour ide n-1jusqu'à 0. C'est ce que fait le code:

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

Je trouve le bonus "dors un peu entre chaque ligne" un peu vague et louche, mais voici une version à 19 octets qui décroche simplement après chaque ligne en calculant toutes les permutations du tableau [0 1 .. 7]. Dans l'interpréteur en ligne, cela conduit simplement à l'affichage du résultat final un peu plus tard, mais si vous utilisez l'interpréteur Java, cela imprimera chaque ligne après "dormir un peu":

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

C, 69 octets

magie printf!

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

Version développée avec quelques explications:

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

Et voici un exemple:

$ ./marquee stackoverflow 12

           s
          st
         sta
        stac
       empiler
      empiler
     pileov
    empiler
   empilement
  empiler
 empiler
stackoverflo
flux de transfert
ackoverflow
ckoverflow
koverflow
débordement
verflow
écoulement
flux
couler
faible
ow
w

Pyth, 13 octets

jb.:++K*dQzKQ

Essayez-le en ligne: Compilateur / Exécuteur Pyth

Explication

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

Cela a été utilisé pour écrire les exemples. Solution de base.

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

  f
 fo
foo
oob
oba
bar
arz
rz
z

Javascript ( ES7 Draft ), 61 octets

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 ) entrées codées en dur, 47 octets

En supposant des entrées codées en dur dans les variables s(chaîne) et l(longueur), il peut être réduit à une impression de 47 octets avec une alerte pour chaque ligne:

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

K, 19 octets

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

Placez les xespaces ( x#" ") au début de la chaîne y. Utilisez ensuite la forme "analyse en virgule fixe" de l'opérateur \pour créer l'ensemble des chaînes pivotées. Un point fixe dans K cesse d’itérer si le résultat de l’application de la fonction renvoie un résultat répété ou si l’entrée initiale est réexaminée. Étant donné ![1]que la rotation d'une chaîne se fait pas à pas, ![1]\est un bon idiome pour les permutations cycliques. Ensuite, nous coupons les résultats avec x#'.

Un exemple de parcours:

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

J (22)

Cela a fini plus longtemps que prévu, mais je suppose que ce n'est pas trop grave.

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

Fait amusant: pas du tout [et ]sont réellement assortis, ou ont quelque chose à voir avec l'autre.

Julia, 75 octets

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

Cela crée une fonction non nommée qui accepte une chaîne et un entier en entrée et imprime la sortie. Pour l'appeler, donnez-lui un nom, par exemple f=(s,n)->(...).

Ungolfed + explication:

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

Exemples:

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     

Notez que cette solution est de 66 octets si set nsont supposés exister déjà dans le programme.

QBasic, 56 - 10 = 46

Ceci est golfed QBasic - le autoformatter étendra ?dans PRINTet ajouter quelques espaces. Testé avec QB64 , bien que rien ici ne puisse fonctionner avec DOS QBasic.

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

QBasic est généralement pas bon avec les opérations de chaîne, mais il très bien est une fonction qui renvoie un nombre donné d'espaces!

En prenant certaines libertés avec "l'entrée peut être codée en dur", ce code s'attend à ce que la variable ssoit DIM'd AS STRING, afin d'éviter le $suffixe de type, ainsi que la chaîne affectée set le nombre n.

Exemple de préambule:

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

Sortie:

   s
  st
 str
stri
trin
bague
ing
ng
g

La ligne blanche supérieure peut être éliminée en démarrant la FORboucle à 2 au lieu de 1.

Bonus: Ajouter CLSjuste avant NEXTun maigre quatre octets transforme cela en ... un véritable chapiteau !

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

Ruby, 68 , 55 octets

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

Après une mise à jour de @blutorange:

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

Sortie:

         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

Première soumission demandant donc des critiques.

Haskell, 61 59 54 octets

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

Exemple d'utilisation:

*Main> putStr $ m 6 "stackoverflow"

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

*Main> 

Edit: une ligne vide au début / à la fin est autorisée

Bash, 109 - 10 = 99 octets

Je vois que dans le temps qu'il m'a fallu pour écrire ma solution, j'ai été battu à mort. Néanmoins, j'ai passé trop de temps à l'écrire pour ne pas l'afficher ...

En plus de cela, il a des caractéristiques uniques, comme le temps entre les lignes d'impression pouvant être ajusté par l'utilisateur en fonction de la quantité dans le répertoire courant! (Également quelque peu incohérent, selon le ressenti de votre disque)

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

Exemple:

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 et commenté:

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

Je n'ai jamais vraiment essayé cela auparavant. Suggestions et commentaires bienvenus!

Pure Bash, 61 octets

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

Sortie:

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

57personnages +3pour -i, -net -l. -10personnages pour le sommeil.

-iest utilisé pour l'entrée numérique, qui est stockée dans $^I. Fondamentalement, nous ajoutons des iespaces au début et à la fin de l'entrée, puis nous recherchons tous les icaractères et les parcourons en boucle while. sayretourne commodément 1que nous pouvons entrer 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

Je sais que cela ressemble plus à Perl, mais c'est vraiment une coquille!

La première ligne ajoute les espaces de début nécessaires, uniquement lors de la première fois dans la boucle. Il définit $ 3 pour indiquer qu'il l'a fait.

La deuxième ligne (nouvelle ligne incorporée dans NB) est récursive jusqu'à épuisement de l'entrée. Elle affiche les n premiers caractères de la chaîne, puis s'invoque elle-même en supprimant le premier caractère de $ 1.

Testé avec Debian /bin/dash- Des exemples de sorties suivent:

./marquee "test" 4

   t
  te
 tes
test
esti
stin
ting
ing
ng
g

./marquee "Quelque chose d'un peu plus long" 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 "petit" 15

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

Python 2, 51 octets / 37 octets

Sans entrée codée en dur (51 octets):

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

Appeler comme f("testing", 4) .

Avec entrée codée en dur (37 octets):

s="testing";n=4

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

Les deux versions génèrent une première ligne d'espaces.

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

(J'ai supposé que la ligne pour l'entrée codée en dur n'ajoutait pas au nombre d'octets.)

Je n'ai pas encore vu de programme qui dort réellement entre les lignes d'impression, alors j'en ai créé un, car il ressemble plus à un chapiteau de cette façon. Ce programme contient 2 octets supplémentaires dans Python 3.

EDIT: Le programme effectue maintenant un calcul au lieu de dormir. J'ai utilisé idans le calcul pour que le programme ne le stocke pas comme une constante, mais doit le calculer à chaque fois.

Essayez celui de Python 3 ici (le remplaçant de Python 2 est bogué)

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

Pyth, 12 octets

jb.:X*dyQQzQ

Manifestation.

Pyth, 17 - 10 = 7 octets

FN.:X*dyQQzQ&.p9N

Cette version utilise un délai entre les impressions en ligne. Cela se voit sur le compilateur en ligne de commande, que vous pouvez obtenir ici .

Exécutez ce qui suit:

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

Cela a un délai d'environ 0,3 secondes avant chaque impression. Si vous préférez un délai plus long, vous pouvez utiliser:

FN.:X*dyQQzQ&.pTN

Cela a environ un délai de 4 secondes.

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

Version longue:

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

Le remplissage est appliqué à la chaîne, puis les sous-chaînes de la chaîne complétée sont imprimées sur la console.

-4 octets grâce à @KevinCruijssen.

Matlab, 95

Comme toujours, il s’agit d’une manipulation de matrices. Le noyau ici est la commande spdiagsqui vous permet de créer très facilement des matrices diagonales.

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

Avec codage en dur 71 octets (la chaîne attendue est stockée tet le nombre entré 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 caractères

Je suis sûr que ça pourrait être plus court. 50 est la longueur du programme sans les deux constantes.

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

Explication:

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

Développé pour ngn APL sur le terminal.

Powershell - 85 83 octets

Il est tard, ça ne va pas gagner :-) Mais je pensais en rajouter un Powershell:

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 octets

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 octets

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

Programme complet avec méthode non golfée et cas de test:

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

        }
    }
}

Gelée , 15 octets - 10 = 5 ( non compétitif ?)

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

Essayez-le en ligne!

Dort pendant une seconde entre chaque ligne. Imprime un retour à la ligne final, si cela est acceptable.

^{yay jelly bat le charbon}

PHP 4.1, 85-10 = 75 octets

Oui, c'est une version très ancienne, mais elle a une fonctionnalité dont j'ai besoin.
Vous pouvez toujours l'exécuter dans n'importe quelle version plus récente de PHP, mais vous devez définir vous-même les variables avant d'exécuter le code ci-dessous.

Cela m'aide à réduire beaucoup la taille de mon code!

C'est vraiment basique:

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

J'ai couru pour le bonus pour cette raison, citant OP:

Si votre programme est autonome (c'est-à-dire lorsqu'il est exécuté, il imprime réellement les lignes) (l'entrée peut être codée en dur mais facile à modifier) ​​et qu'il dort un peu entre chaque ligne de sortie, vous obtenez un bonus de -10.

Comme vous pouvez le constater, il dort.

Cela suppose que vous avez register_globalsactivé par défaut les paramètres par défaut de cette version.

Vous pouvez facilement tester dans votre navigateur, avec minimal quelques changements:

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

Le code ci-dessus est un polyglotte et vous pouvez l'exécuter dans votre navigateur ou dans un interpréteur PHP. Ne devrais-je pas obtenir un prix pour cela? Un cookie peut-être?

Liste des modifications:

• Supprimé le sleep(1)dans ce test
• Création de 2 versions de la fonction concat
  Le but est de surmonter les différences de concaténation de chaînes entre PHP et JS.
• Au lieu d'un espace, un -est utilisé pour remplir l'espace
• Au lieu de echo, printfutilise à la place (limitation PHP)
• À la place ou un "réel" saut de ligne, il <br>utilise à la place

J , 15 14 octets

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

Essayez-le en ligne!

APL (Dyalog) , 17 octets

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

Essayez-le en ligne!

(le programme suppose ⎕IO←0ce qui est le défaut sur beaucoup de machines)

Explication

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