Texto falso de letreiro

46

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.

code-golf  string 
— Caridorc
fonte
O que você quer dizer com "inclui Saída"?
— Optimizer
1
Além disso, temos que imprimir a primeira e a última linhas que são simplesmente espaços?
— Optimizer
2
Inspirado por isso ?
— Spikatrix 13/05/19
1
Uma única linha vazia no início parece ser permitida. Que tal outra linha vazia no final?
— nimi
2
Como você está falando de "somente saída visível", podemos assumir que a entrada será apenas ASCII imprimível? (códigos de caracteres 0x20 a 0x7E)
— Martin Ender

Respostas:

24

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!;}/
— Martin Ender
fonte
Bom uso de z. Supondo que a entrada seja ASCII imprimível, você pode substituir W%por $.
— Dennis
@ Dennis Oh, eu gosto disso. Solicitei esclarecimentos sobre isso ao OP. (Dito isto, eu uso zo tempo todo para os desafios baseados em grade ascii.)
— Martin Ender
15

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
— CL-
fonte
14

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
— Jakube
fonte
6

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
— Caridorc
fonte
2
Eu não testei isso, mas você deve ser capaz de remover os colchetes dentrojoin
— undergroundmonorail
@undergroundmonorail right
— Caridorc
6

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>
Expandir snippet

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))
— nderscore
fonte
5

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   ")
— JohnE
fonte
5

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.

— ɐɔıʇǝɥʇuʎs
fonte
Após 3 pequenas alterações: [{."1]]\.@,~' '#~[(18 bytes).
— Random #
5

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.

— Alex A.
fonte
5

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 !

Letreiro

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

— DLosc
fonte
Eu deveria tentar QBasic de novo ... É o que eu aprendi sobre
— canadense Luke restabelecer MONICA
5

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.

— DickieBoy
fonte
1
Parece bem feito para mim, usando alguns atalhos de rubi. O espaço final não parece ser necessário ("apenas a saída visível importa"), e você pode salvar alguns bytes usando uma variável temporária:a=" "*(z=$*[1].to_i)+$*[0];a.size.times{|b|puts a[b,z]}
— blutorange
@blutorange Obrigado pelo feedback!
— 21415 DickieBoy
De nada. Sinta-se livre para editar a resposta se você gostaria;)
— blutorange
4

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

— nimi
fonte
4

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!

— Sompom
fonte
4

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
$
— Trauma Digital
fonte
Acho que não entendo a distinção Bash "pura", então talvez essa sugestão não seja boa, mas sleep (1) tem 8 caracteres e fornece -10 (e é um GNU Core Util)
— Sompom
3

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)'
— hmatt1
fonte
Eu sei que isto é antiga, mas é só um pulo para trás para a primeira página e eu tive um ir para diminuir esse baixo um pouco: s/^|$/$"x$^I/eg;sleep say$1 while s/.(.{$^I})/$1/. Você também pode perder a -lbandeira, mas eu acho que você precisa para contar 5 para -i -n(uma vez que -inão é uma bandeira padrão) se você executar via: echo -n "testing" | perl -i4 -nE'...'. Ainda deve ser baixo para 44 embora!
— Dom Hastings
@DomHastings thanks Dom! Bom trabalho, eu vou editar a minha resposta depois :)
— hmatt1
3

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
— Toby Speight
fonte
Posso adicionar 9 caracteres para obter o bônus -10! ["$ 1"] && printf "% -. $ {2} s" "$ 1" "" && sleep 1 && $ 0 "$ {1 #?}" $ 2 t
— Toby Speight
3

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.

— Sp3000
fonte
3

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
— mbomb007
fonte
Talvez em vez de time.sleephaver algum cálculo longo que você possa usar? Além disso, é um pouco mais curto usar um whileloop:i=0\nwhile s[i-n:]:print(' '*n+s)[i:n+i];i+=1
— xnor 14/05
A exponenciação @xnor algumas vezes funciona muito bem para um cálculo.
— Mbomb007
@ mbomb007 Acho que você não precisa armazenar o valor da computação para que o python faça isso de verdade (para que você possa salvar 'q ='). Além disso, x ^ 7 ^ 7 é matematicamente equivalente a x ^ 49, embora o python pareça resolver o último um pouco mais rápido para mim. Você pode salvar alguns caracteres dessa maneira.
— Sompom
@Sompom Experimente no repl. Se eu consolidar a expressão em uma única exponenciação, ela removerá completamente o atraso. Mas eu vou remover q=. Obrigado.
— Mbomb007
@Sompom exponenciação é associativa à direita, de modo que este é realmentei**(7**7)
— SP3000
3

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.

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

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.

— TNT
fonte
Eu sei que tem sido mais de um ano, mas você pode golfe no segundo ciclo for um pouco: for(;i<= s.length();System.out.println(s.substring(i-n,i++)));( -3 bytes )
— Kevin Cruijssen
1
Não significa que não possa ser melhorado. :) Obrigado.
— TNT
2

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))))
— flawr
fonte
2

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.

— Tobia
fonte
2

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

— Chris J
fonte
1

Cobra - 60

def f(n,s)
    s=' '.repeat(n)+s
    while''<s,print (s=s[1:])[:n]
— Furioso
fonte
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
fonte
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
— Blab
fonte
1

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

        }
    }
}
— adrianmp
fonte
1

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}
Expandir snippet

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
— Ismael Miguel
fonte
1

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
— Kritixi Lithos
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.