Testo di selezione falso

46

In questa sfida, il testo a tendina falso è un testo che viene mostrato parte per parte, in modo scorrevole.

Qualche esempio:

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

Devi scrivere un programma o una funzione che accetta due input e stampa l'output come descritto sopra. È possibile o meno l'output di spazi finali nell'output. Questo è code-golf, quindi vince il codice più breve in byte.

Se il tuo programma è autonomo (cioè quando viene effettivamente eseguito stampa le righe) (l'input può essere hardcoded ma facile da cambiare) e dorme un po 'tra ogni riga di output ottieni un bonus di -10.

code-golf  string 
— Caridorc
fonte
Cosa intendi con "include output"?
— Ottimizzatore
1
Inoltre, dobbiamo stampare la prima e l'ultima riga che sono semplicemente spazi?
— Ottimizzatore
2
Ispirato da questo ?
— Spikatrix,
1
Una sola riga vuota all'inizio sembra essere consentita. Che ne dici di un'altra riga vuota alla fine?
— nimi,
2
Dato che stai parlando di "solo output visibile", possiamo supporre che l'input sarà solo ASCII stampabile? (codici carattere da 0x20 a 0x7E)
— Martin Ender,

Risposte:

24

CJam, 12 11 byte

1 byte salvato da Dennis.

,Sf*\f+$zN*

Sto facendo uso di "L'input può essere hardcoded ma facile da modificare": questo prevede che l'input sia già nello stack, quindi puoi anteporre "testing" 4a quanto sopra, per esempio.

Provalo qui.

Spiegazione

Si noti che la trasposizione dell'output desiderato è molto più semplice:

   testing
  testing
 testing
testing

Quindi abbiamo solo bisogno di creare nlinee, anteponendo ispazi per idal n-1basso al 0. Ecco cosa fa il codice:

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

Trovo il bonus "dorme un po 'tra ogni linea" un po' vago e sfuggente, ma qui c'è una versione a 19 byte che si blocca semplicemente dopo ogni linea calcolando tutte le permutazioni dell'array [0 1 .. 7]. Nell'interprete online questo porta semplicemente a mostrare il risultato finale un po 'più tardi, ma se usi l'interprete Java questo stamperà effettivamente ogni riga dopo "dormire un po'":

,Sf*\f+$z{oNo8e!;}/
— Martin Ender
fonte
Buon uso di z. Supponendo che l'ingresso sia ASCII stampabile, è possibile sostituirlo W%con $.
— Dennis,
@Dennis Oh, mi piace. Ho chiesto chiarimenti in merito all'OP. (Detto questo, lo uso zsempre per le sfide ASCII basate sulla griglia.)
— Martin Ender,
15

C, 69 byte

magia della stampa!

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

Versione estesa con alcune spiegazioni:

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

Ed ecco un esempio:

$ ./marquee stackoverflow 12

           S
          st
         STA
        stac
       pila
      stacko
     stackov
    stackove
   stackover
  stackoverf
 stackoverfl
stackoverflo
tackoverflow
ackoverflow
ckoverflow
koverflow
straripamento
verflow
erflow
rflow
flusso
Basso
OW
w
— CL-
fonte
14

Pyth, 13 byte

jb.:++K*dQzKQ

Provalo online: Pyth Compiler / Executor

Spiegazione

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

Questo è stato effettivamente utilizzato per scrivere gli esempi. Soluzione di base.

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

  f
 fo
foo
oob
oba
bar
arz
rz
z
— Caridorc
fonte
2
non l'ho provato ma dovresti essere in grado di rimuovere le parentesi quadre all'internojoin
— undergroundmonorail
@undergroundmonorail right
— Caridorc
6

Javascript ( ES7 Draft ), 61 byte

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>
Espandi frammento

Ingressi hardcoded Javascript ( ES6 ), 47 byte

Supponendo che gli input codificati nelle variabili s(stringa) e l(lunghezza), possano essere ridotti a 47 byte stampando con un avviso per ogni riga:

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

K, 19 byte

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

Applica gli xspazi ( x#" ") all'inizio della stringa y. Quindi utilizzare il modulo "Scansione a virgola fissa" dell'operatore \per creare l'insieme di stringhe ruotate. Un punto fisso in K interrompe l'iterazione se il risultato dell'applicazione della funzione restituisce un risultato ripetuto o se l'ingresso iniziale viene rivisitato. Poiché ![1]ruoterà una stringa di un passo alla volta, ![1]\è un bel linguaggio per permutazioni cicliche. Quindi tagliamo i risultati con x#'.

Una corsa di esempio:

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

Questo è finito più a lungo di quanto mi aspettassi, ma credo che non sia poi così male.

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

Curiosità: non del [e ]sono effettivamente abbinati, o hanno qualcosa a che fare l'uno con l'altro.

— ɐɔıʇǝɥʇuʎs
fonte
Dopo 3 piccole modifiche: [{."1]]\.@,~' '#~[(18 byte).
— randomra,
5

Julia, 75 byte

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

Ciò crea una funzione senza nome che accetta una stringa e un numero intero come input e stampa l'output. Per chiamarlo, dagli un nome, ad es f=(s,n)->(...).

Ungolfed + spiegazione:

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

Esempi:

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

Si noti che questa soluzione è di 66 byte se se nsi presume che esista già nel programma.

— Alex A.
fonte
5

QBasic, 56-10 = 46

Questo è giocato a golf a QBasic - l'autoformatter si espanderà ?in PRINTe aggiungere alcuni spazi. Testato con QB64 , anche se qui non dovrebbe esserci nulla che non funzioni con DOS QBasic.

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

QBasic in generale non è buona con operazioni sulle stringhe, ma c'è molto convenientemente è una funzione che restituisce un dato numero di spazi!

Prendendo alcune libertà con "input può essere hardcoded", questo codice prevede che la variabile ssia DIM'd AS STRING, al fine di evitare il $suffisso del tipo, nonché la stringa assegnata se il numero a n.

Esempio di preambolo:

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

Produzione:

   S
  st
 str
stri
trin
squillare
ing
ng
g

La riga vuota superiore può essere eliminata avviando il FORloop da 2 anziché 1.

Bonus: l' aggiunta CLSappena prima NEXTdi un misero quattro byte lo trasforma in ... un vero tendone !

Tendone

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

— DLosc
fonte
Dovrei provare di nuovo QBasic ... È quello che ho imparato per la prima volta
— Canadian Luke REINSTATE MONICA
5

Rubino, 68 , 55 byte

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

Dopo un aggiornamento da @blutorange:

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

Produzione:

         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

Prima presentazione quindi chiedendo critiche.

— DickieBoy
fonte
1
Mi sembra ben fatto, usando alcune scorciatoie rubino. Lo spazio finale non sembra essere necessario ("solo l'output visibile conta") e puoi salvare alcuni byte usando una variabile temporanea:a=" "*(z=$*[1].to_i)+$*[0];a.size.times{|b|puts a[b,z]}
— blutorange
@blutorange Grazie per il feedback!
— DickieBoy,
Prego. Sentiti libero di modificare la risposta, se lo desideri;)
— blutorange
4

Haskell, 61 59 54 byte

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

Esempio di utilizzo:

*Main> putStr $ m 6 "stackoverflow"

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

*Main>

Modifica: è consentita una riga vuota all'inizio / alla fine

— Nome del modello
fonte
4

Bash, 109-10 = 99 byte

Vedo che nel tempo che ho impiegato per scrivere la mia soluzione, sono stato battuto profondamente. Tuttavia, ho trascorso troppo tempo a scriverlo per non pubblicarlo ...

Oltre a ciò, ha alcune caratteristiche uniche, come il tempo che intercorre tra la stampa delle righe e la sua regolazione in base a quanto è nella directory corrente! (Anche in qualche modo incoerente, a seconda di come si sente il tuo 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

Esempio:

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

Ungolf e commentato:

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

Non l'ho mai provato prima. Suggerimenti e commenti benvenuti!

— Sompom
fonte
4

Pure Bash, 61 byte

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

Produzione:

$ ./marquee.sh testing 4
   t
  te
 tes
test
esti
stin
ting
ing
ng
g
$
— Trauma digitale
fonte
Immagino di non capire la distinzione "puro" Bash, quindi forse questo suggerimento non è buono, ma sleep (1) è di 8 caratteri e ti dà -10 (ed è un GNU Core Util)
— Sompom
3

Perl, 50

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

57personaggi +3per -i, -ne -l. -10personaggi per il sonno.

-iviene utilizzato per l'ingresso numerico, che è memorizzato in $^I. Fondamentalmente, aggiungiamo ispazi all'inizio e alla fine dell'input, quindi cerchiamo tutti i icaratteri e li attraversiamo while. sayrestituisce comodamente 1ciò a cui possiamo inserire sleep.

echo "testing" | perl -i4 -nlE'$c=$" x$^I;$_="$c$_$c";sleep say$1while(/(?<=(.{$^I}))/g)'
— hmatt1
fonte
So che questo è vecchio, ma è appena tornato alla prima pagina e ho provato a ridurlo un po ': s/^|$/$"x$^I/eg;sleep say$1 while s/.(.{$^I})/$1/. Si può anche perdere la -lbandiera, ma penso che hai bisogno di contare 5 per -i -n(dal momento che -inon è una bandiera di default) se si esegue tramite: echo -n "testing" | perl -i4 -nE'...'. Dovrebbe comunque essere ridotto a 44!
— Dom Hastings,
@DomHastings grazie Dom! Bel lavoro, modificherò la mia risposta più tardi :)
— hmatt1
3

Shell POSIX, 94

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

So che sembra più vicino al perl, ma questo è davvero shell!

La prima riga aggiunge gli spazi iniziali necessari, solo alla prima volta attraverso il loop. Imposta $ 3 per indicare che lo ha fatto.

La seconda riga (NB newline incorporato) ricicla fino a quando l'input è esaurito, stampando i primi n caratteri della stringa, quindi invocando se stesso con il primo carattere rimosso da $ 1.

Testato con Debian /bin/dash- seguono esempi di output:

"testing" ./marquee 4

   t
  te
 tes
test
esti
stin
ting
ing
ng
g

./marquee "Qualcosa di più lungo" 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 "piccolo" 15

              s
             sm
            sma
           smal
          small
         small
        small
       small
      small
     small
    small
   small
  small
 small
small
mall
all
ll
l
— Toby Speight
fonte
Posso aggiungere 9 caratteri per ottenere il bonus di -10! ["$ 1"] && printf "% -. $ {2} s" "$ 1" "" && sleep 1 && $ 0 "$ {1 #?}" $ 2 t
— Toby Speight
3

Python 2, 51 byte / 37 byte

Senza input hardcoded (51 byte):

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

Chiama come f("testing", 4).

Con input hardcoded (37 byte):

s="testing";n=4

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

Entrambe le versioni producono una riga iniziale di spazi.

— SP3000
fonte
3

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

(Ho ipotizzato che la riga per l'input codificato non si aggiunga al conteggio dei byte.)

Non ho ancora visto un programma che effettivamente dorme tra le linee di stampa, quindi ne ho creato uno che lo fa, dato che sembra più un riquadro di selezione in quel modo. Questo programma contiene altri 2 byte in Python 3.

EDIT: il programma ora esegue un calcolo invece di dormire. Ho usato inel calcolo in modo che il programma non lo memorizzi come costante, ma deve calcolarlo ogni volta.

Prova qui Python 3 (il sostituto di Python 2 è difettoso)

i=0
while s[i-n:]:print((' '*n+s)[i:n+i]);i+=1;i**7**7
— mbomb007
fonte
Forse invece di time.sleepun lungo calcolo che puoi usare? Inoltre, è un po 'più breve usare un whileloop:i=0\nwhile s[i-n:]:print(' '*n+s)[i:n+i];i+=1
— xnor
@xnor Exponentiation un paio di volte funziona abbastanza bene per un calcolo.
— mbomb007,
@ mbomb007 Non credo che sia necessario memorizzare il valore del calcolo per ottenere che Python lo esegua effettivamente (in modo da poter salvare 'q ='). Inoltre, x ^ 7 ^ 7 equivale matematicamente a x ^ 49, anche se Python sembra risolverlo leggermente più velocemente per me. Puoi salvare alcuni personaggi in questo modo.
— Sompom,
@Sompom Provalo nella sostituzione. Se consolido l'espressione in una singola esponenziazione, rimuove completamente il ritardo. Ma lo rimuoverò q=. Grazie.
— mbomb007,
@Sompom Exponentiation è un'associazione giusta, quindi in realtà lo èi**(7**7)
— Sp3000,
3

Pyth, 12 byte

jb.:X*dyQQzQ

Dimostrazione.

Pyth, 17-10 = 7 byte

FN.:X*dyQQzQ&.p9N

Questa versione impiega un ritardo tra le stampe di linea. Questo può essere visto sul compilatore della riga di comando, che puoi ottenere qui .

Eseguire quanto segue:

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

Questo ha un ritardo di circa 0,3 secondi prima di ogni stampa. Se si preferisce un ritardo più lungo, è possibile utilizzare:

FN.:X*dyQQzQ&.pTN

Questo ha un ritardo di circa 4 secondi.

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

Versione lunga:

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

L'imbottitura viene applicata alla stringa, quindi le sottostringhe della stringa imbottita vengono stampate sulla console.

-4 byte grazie a @KevinCruijssen.

— TNT
fonte
So che è passato più di un anno, ma puoi giocare un po 'a golf il secondo for-loop: for(;i<= s.length();System.out.println(s.substring(i-n,i++)));( -3 byte )
— Kevin Cruijssen,
1
Non significa che non può essere migliorato. :) Grazie.
— TNT,
2

Matlab, 95

Come sempre, è una manipolazione di matrici. Il nucleo qui è il comando spdiagsche ti consente di creare matrici diagonali molto facilmente.

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 hardcoding 71 byte (stringa prevista memorizzata in te il numero in 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 caratteri

Sono sicuro che potrebbe essere più breve. 50 è la lunghezza del programma senza le due costanti.

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

Spiegazione:

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

Sviluppato per ngn APL sul terminale.

— Tobia
fonte
2

Powershell - 85 83 byte

È tardi, non vincerà :-) Ma ho pensato di lanciarne uno Powershell per completezza:

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]
— Οurous
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 byte

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
— spifferare
fonte
1

C #, 112 byte

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

Programma completo con metodo non golfizzato e casi di 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));

        }
    }
}
— adrianmp
fonte
1

PHP4.1, 85-10 = 75 byte

Sì, questa è una versione molto vecchia, ma ha una funzionalità di cui ho bisogno.
Puoi ancora eseguirlo in qualsiasi versione più recente di PHP, ma devi impostare tu stesso le variabili prima di eseguire il codice qui sotto.

Questo mi aiuta a ridurre molto le dimensioni del mio codice!

È davvero di base:

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

Ho corso per il bonus a causa di questo, citando OP:

Se il tuo programma è autonomo (cioè quando viene effettivamente eseguito stampa le righe) (l'input può essere hardcoded ma facile da cambiare) e dorme un po 'tra ogni riga di output ottieni un bonus di -10.

Come puoi ovviamente vedere, ha un sonno.

Ciò presuppone che tu abbia register_globalsabilitato per impostazione predefinita, che erano le impostazioni predefinite per questa versione.

Puoi facilmente testare nel tuo browser con minimo alcuni cambiamenti:

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

Il codice sopra è un poliglotta e puoi eseguirlo nel tuo browser o in un interprete PHP. Non dovrei ottenere un premio per questo? Un biscotto, forse?

Elenco delle modifiche:

  • Rimosso sleep(1)in questo test
  • Create 2 versioni della funzione concat
    L'obiettivo è superare le differenze PHP e JS nella concatenazione di stringhe.
  • Invece di uno spazio, a -viene utilizzato per riempire lo spazio
  • Invece di echo, printfè usi invece (limitazione di PHP)
  • Invece o una newline "reale", <br>è invece usi
— Ismael Miguel
fonte
1

APL (Dyalog) , 17 byte

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

Provalo online!

(il programma presuppone ⎕IO←0che sia predefinito su molte macchine)

Spiegazione

⍳⎕               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
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.