Disegna l'arco di una palla

35

Disegna la traiettoria parabolica di una palla lanciata.

L'ingresso è la velocità iniziale verso l'alto della palla, un numero intero positivo v. Ogni secondo, la palla si sposta di 1spazio a destra e vspazi in verticale, quindi vdiminuisce 1a causa della gravità. Quindi, la velocità verso l'alto alla fine scende da va 0e giù a -v, ricadendo infine alla sua altezza iniziale.

Le posizioni della palla tracciano una parabola. In posizione orizzontale x, la sua altezza è y=x*(2*v+1-x)/2, con (0,0)la posizione iniziale della palla in basso a sinistra.

Crea arte ASCII della traiettoria della palla con Ole coordinate che occupa mai. L'output dovrebbe essere un singolo pezzo di testo su più righe, non un'animazione del percorso nel tempo.

L'output non dovrebbe avere newline iniziali e al massimo una newline finale. La linea di fondo dovrebbe essere a filo con il bordo sinistro dello schermo, cioè non avere spazi iniziali aggiuntivi. Gli spazi finali sono OK. È possibile supporre che la larghezza della linea di uscita si adatti al terminale di uscita.

v = 1

 OO 
O  O

v = 2

  OO  
 O  O 

O    O

v = 3

   OO   
  O  O  

 O    O 


O      O

v = 4

    OO    
   O  O   

  O    O  


 O      O 



O        O

v = 10

          OO          
         O  O         

        O    O        


       O      O       



      O        O      




     O          O     





    O            O    






   O              O   







  O                O  








 O                  O 









O                    O

Correlati: simulazione di palla che rimbalza

Classifica:

Mostra snippet di codice

code-golf  ascii-art  physics 
— XNOR
fonte
Possiamo creare un elenco di righe?
— R
@Riker No, stringa con newline.
— xnor
— Tito
Devo solo tenere conto di V> 0?
— nmjcman101
Sì, v sarà positivo.
— xnor

Risposte:

17

Carbone , 18 16 13 byte

-3 byte grazie a @Neil !

Ｆ⊕Ｎ«←OＭ⊕ι↓»‖Ｃ

Spiegazione

Ｆ⊕Ｎ«        »    For ι (implicitly from 0) to (1 + input as number)
       ←O          Print O, with print direction rotated 180 degrees
         Ｍ⊕ι↓     Move 1+ ι units down

                ‖Ｃ Reflect (in the default direction, right), leaving original intact

Provalo online! Il collegamento è al codice dettagliato.

— ASCII-only
fonte
Mi piace molto questo, +1; Anche l'output di OP utilizza "O" maiuscola. (Non è affatto importante lol)
— Albert Renshaw,
Se lo usi, puoi invece ↘Opassare da 0 a N inclusi, il che ti consente di risparmiare immediatamente due byte.
— Neil,
@Neil Grazie! Inoltre, questo è un post molto vecchio: P (e mi chiedo se dovrei usare nuove funzionalità. Probabilmente no?)
— ASCII il
A rigor di termini Ti ho salvato solo 1 byte misura in cui gli altri due byte sono stati voi sostituendo ⁺¹con ⊕. Tuttavia ora che hai spostato ←da ‖Ｃa Opuoi salvare un altro byte scrivendo ↙OＭι↓, quindi torno nuovamente a un salvataggio a due byte.
— Neil,
Inoltre hai dimenticato di aggiornare il tuo link TIO. E tecnicamente credo che ora consentiamo nuove funzionalità, ma non posso rivendicare credito per quei byte.
— Neil,
6

C, 93 92

(Nota, qualcuno ha ottenuto 87 nei commenti)

y,n;f(s){for(y=0;y<=s;){printf("%*c%*c",s-y+1,79,y*2+1,79);for(n=++y;s+1-n&&n--;)puts("");}}

Provalo online!

Leggibile: 

y,n;f(s){
    for(y=0;y<=s;){
        printf("%*c%*c",s-y+1,79,y*2+1,79);
        for(n=++y;s+1-n&&n--;)puts("");
    }
}

Gli appunti:

Posso comprimere entrambi i loop in uno solo per loop ripetendo il numero totale di linee emesse, che è dato dalla formula: n*-~n/2+1

y,n,r;f(s){
    for(r=s,y=n=0;r<s*-~s/2+1;)
        y==n?printf("%*c%*c",s-y+1,79,y*2+1,79),y=0,++n:r++,y++,puts("");
}

Ma finisce per essere ancora più byte rispetto al semplice utilizzo di due for-loop separati

— Albert Renshaw
fonte
È possibile salvare un byte incrementando sall'inizio, in questo modo:y,n;f(s){++s;for(y=0;y<s;){printf("%*c%*c",s-y,79,y*2+1,79);for(n=++y;s-n&&n--;)puts("");}}
— Steadybox
@Steadybox non verrà compilato per me. Inoltre ho ottenuto 90 byte quando l'ho contato (dopo aver rimosso i caratteri degli spazi)
— Albert Renshaw
Tutto quello che ho fatto è stato aggiungere ++s;all'inizio e poi cambiare y<=sin y<se s-y+1in s-ye s+1-nin s-n, quindi dovrebbe compilare (e dovrebbe essere 91 byte).
— Steadybox
Sembra che ci sia qualcosa di sbagliato nella codifica del blocco di codice nel mio commento. Copiare e incollare il codice dal commento non verrà compilato neanche per me.
— Steadybox
1
— ceilingcat
5

GNU sed, 41

  • Il punteggio include +1 dalle -rbandiere a sed.
s/$/OO/
:
s/(\s*) O( *)O$/&\n\1O \2 O/
t

L'input è in unario, come una stringa di spazi - la lunghezza della stringa è l'input.

Provalo online .

— Trauma digitale
fonte
4

Python 2, 76 byte

x=input()
for i in range(x):print' '*(x-i),'O'+' '*i*2+'O'+'\n'*(i-x+1and i)

Abbastanza semplice. Lo scopo i-x+1and iè prevenire un sacco di nuove righe finali.

— HyperNeutrino
fonte
Spostando la nuova riga all'inizio della stampa, si '\n'*(i-1)risparmiano 7 byte evitando le nuove righe finali.
— Emigna
4

MATL , 19 17 byte

Q:tqYsQ79Z?PtPv!c

Provalo su MATL Online! Oppure verifica tutti i casi di test .

Spiegazione

Q        % Implicitly input v. Add 1
:        % Push [1 2 ... v+1]
tq       % Duplicate and subtract 1: pushes [0 1 ... v]]
Ys       % Cumulative sum: gives [0 1 3 6 ...]
Q        % Add 1: gives [1 2 4 7 ...]
79       % Push 79 (ASCII for 'O')
Z?       % Create sparse matrix from column indices [1 2 3 4 ...],
         % row indices [1 2 4 7 ...], and data 79
P        % Flip vertically
tP       % Duplicate, flip vertically
v        % Concatenate the two matrices vertically
!        % Transpose
c        % Convert to char. Implicitly display. Char 0 is shown as space
— Luis Mendo
fonte
4

05AB1E , 18 14 byte

Salvati 4 byte grazie ad Adnan

ƒ¶N×'ONúRÂJ}.c

Provalo online!

Spiegazione

ƒ                   # for N in [0 ... input]
 ¶N×                # push N newlines
    'O              # push "O"
      Nú            # pad with N spaces in front
        RÂ          # reverese and create a reversed copy
          J         # join everything to a string
           }        # end loop
            .c      # pad lines until centered
— Emigna
fonte
Per 14 byte: ƒ¶N×'ONúRÂJ}.c:)
— Adnan
@Adnan Grazie! Ho provato .ccon una versione diversa, ma allora non ha funzionato bene. Dimenticato di provarlo con questo e completo dimenticato che úesiste :)
— Emigna
Decisamente migliore del metodo zip che ho scelto, approccio interessante in verticale.
— Magic Octopus Urn
4

JavaScript (ES6), 98 92 89 84 78 byte

(-20 byte grazie ad Arnauld!)

f=(v,i=0)=>i>v?"":" "[r="repeat"](v-i)+0+" "[r](2*i)+0+`
`[r](i++<v&&i)+f(v,i)

Una soluzione ricorsiva. Questa è anche la mia prima risposta in assoluto in JavaScript, quindi per favore sii gentile! Sto ancora imparando tutto ciò che questa lingua accurata ha da offrire, quindi i consigli sul golf sono molto apprezzati. :)

Test dello snippet

Potrebbe essere necessario scorrere per visualizzare l'intero output.

f=(v,i=0)=>i>v?"":" "[r="repeat"](v-i)+0+" "[r](2*i)+0+`
`[r](i++<v&&i)+f(v,i)
<input id=i min=1 type=number><button onclick=alert(f(document.getElementById("i").value))>Submit</button>
Espandi frammento

— R. Kap
fonte
Inoltre, includendo le variabili all'interno delle stringhe backtick con ${}salva solo i byte quando la parte variabile è circondata da parti statiche. Pertanto, queste stringhe devono sempre iniziare e terminare con parti statiche.
— Luca
@Arnauld Grazie per tutti i suggerimenti! Lo apprezzo molto! :)
— R. Kap
@Luke Grazie per il consiglio. Sarà utile. :)
— R. Kap
Puoi usare tranquillamente 0invece di "0". Saranno costretti a stringhe. E a pensarci bene: in i++<v&&irealtà è un byte più corto di (i<v)*++i.
— Arnauld
@Arnauld Grazie ancora! :)
— R. Kap
3

RProgN 2 , 37 byte

x=0xR{y@xy-` *`o` y2**`o...2y{[` };};

Entrare con la mia lingua da golf prima che entrino in gioco i linguaggi golfistici appropriati.

spiegato

x=              # Set 'x' to the input
0xR{            # For everything between the input and 0
    y@          # Set the iteration value to y, for this function only.
    xy-` *      # Subtract y from x, repeat the string " " that many times.
    `o          # Push an "o" to the stack.
    ` y2**      # Push 2*y " "'s to the stack
    `o          # Push another "o" to the stack
    ...         # Concatenate the parts of this string together, giving us the two balls.
    2y{[` };    # For all numbers between 2 and y, add a newline.
};              #

Provalo online!

— ATACO
fonte
3

Retina, 29 19 byte

 ?
$.`$*¶$&$'O$`$`O

Provalo online!

Riceve input in unario come una serie di spazi. Porta della mia risposta JavaScript. Modifica: salvato 10 byte grazie a @ MartinEnder ♦.

— Neil
fonte
Sto solo aspettando che qualcuno tiri fuori uno spin off di Retina chiamato Retsina.
— Tito
3

Bash , 76 byte

for((n=$1+1;--n;));{
yes ''|head -$n
r=$r›${n}AO
t=›${n}BO$t
}
echo O${r}O$t

Funziona solo in un terminale poiché utilizza sequenze di escape ANSI . ›rappresenta il byte CSI ( 0x9b ).

Prova

$ # The terminal's encoding must be set to ISO-8859-1.
$
$ xxd -g 1 arc.sh
0000000: 66 6f 72 28 28 6e 3d 24 31 2b 31 3b 2d 2d 6e 3b  for((n=$1+1;--n;
0000010: 29 29 3b 7b 0a 79 65 73 20 27 27 7c 68 65 61 64  ));{.yes ''|head
0000020: 20 2d 24 6e 0a 72 3d 24 72 9b 24 7b 6e 7d 41 4f   -$n.r=$r.${n}AO
0000030: 0a 74 3d 9b 24 7b 6e 7d 42 4f 24 74 0a 7d 0a 65  .t=.${n}BO$t.}.e
0000040: 63 68 6f 20 4f 24 7b 72 7d 4f 24 74              cho O${r}O$t
$
$ bash arc.sh 1
 OO
O  O
$ bash arc.sh 2
  OO
 O  O

O    O
$ bash arc.sh 3
   OO
  O  O

 O    O


O      O
$ bash arc.sh 4
    OO
   O  O

  O    O


 O      O



O        O
— Dennis
fonte
È possibile utilizzare sed $nqper salvare un byte.
— Zeppelin,
Purtroppo no. Dovrei usare quello sed ${n}qche è più lungo.
— Dennis
Argh, vedo, puoi fare sed $n\qinvece, ma non ha neanche molto senso, dato che sarebbe lo stesso conteggio byte di head!
— Zeppelin,
3

R, 89 byte

a=2*v+3
x=matrix(" ",a,v^2+1)
for(k in 0:v)x[c(1-k,k+2)+v,k^2+1]="o"
x[a,]="\n"
cat(x,sep="")
  • Crea una matrice di spazi (la variabile a è la larghezza di questa matrice, salvando un paio di byte)
  • Inserire "o" nelle posizioni richieste, lavorando dall'alto verso il basso e verso l'esterno
  • Aggiungi una nuova riga alla fine di ogni riga della matrice
  • Comprimi la matrice in un'unica stringa e stampa

Questo è il mio primo tentativo di giocare a golf, commenti benvenuti ...

— user2390246
fonte
3

Röda , 53 52 byte

f n{seq 0,n|{|i|["
"*i," "*(n-i),"O"," "*i*2,"O"]}_}

Provalo online!

Uso: main { f(5) }

Versione non golfata:

function f(n) {
    seq(0, n) | for i do
        push("\n"*i, " "*(n-i), "O", " "*i*2, "O")
    done
}
— fergusq
fonte
Puoi usare una nuova riga letterale invece di \ne salvare 1 byte?
— Kritixi Lithos,
@KritixiLithos Funziona. Grazie!
— Fergusq,
2

Befunge, 75 73 byte

<vp00:&
1<-1_:v#\+55:g01\-g01g00" O"1\*2g01" O"1p0
#@_\:v>$$:!
1\,:\_^#:-

Provalo online!

La prima riga legge in velocity, v , e salva una copia in memoria. La seconda riga quindi conta alla rovescia da v a zero, con l'indice i , e su ogni iterazione inserisce una sequenza di coppie carattere / lunghezza nella pila.

Length  Character
-----------------
1       'O'
i*2     ' '
1       'O'
v-i     ' '
i       LINEFEED

Questa sequenza rappresenta una specie di codifica della lunghezza di esecuzione dell'output richiesto al contrario. Le ultime due righe quindi estraggono semplicemente queste coppie di caratteri / lunghezza dalla pila, producendo occorrenze di lunghezza di ciascun personaggio , fino a quando la pila non è vuota.

— James Holderness
fonte
2

Java 8, 129 124 109 byte

golfed:

v->{String s="",t="";for(int j,y=0;y<=v;++y){for(j=0;j<v;++j)s+=j<y?"\n":" ";s+="o"+t+"o";t+="  ";}return s;}

Provalo online!

Ungolfed:

public class DrawTheArcOfABall {

  public static void main(String[] args) {
    for (int i = 1; i < 6; ++i) {
      System.out.println(f(v -> {
        String s = "", t = "";
        for (int j, y = 0; y <= v; ++y) {
          for (j = 0; j < v; ++j) {
            s += (j < y ? "\n" : " ");
          }
          s += "o" + t + "o";
          t += "  ";
        }
        return s;
      } , i));
      System.out.println();
      System.out.println();
    }
  }

  private static String f(java.util.function.IntFunction<String> f, int v) {
    return f.apply(v);
  }
}
— Colpisci il
Per il secondo ciclo annidato, penso for(;j<v;++)che funzionerebbe, perché a questo punto nel tempo j==y. Inoltre, è possibile rimuovere il terzo aggiungendo una seconda variabile di stringa all'interno del ciclo principale per String t="";(12) e t+=" ";(8) all'interno del primo ciclo nidificato. Quindi il terzo ciclo diventas+="o"+t+"o";
— nmjcman101
Inoltre, puoi combinare i primi due cicli nidificati a for(j=0;j<v;++j)s+=j<y?"\n":" ";anche se non sono sicuro di come si intreccia con il mio precedente commento sut
— nmjcman101
Puoi inizializzare t=""insieme a s all'inizio, quindi aggiungere t+=" "ogni giro intorno dopo averlo fattos+="o"+t+"o"
— nmjcman101
2

VBA, 124 112 85 88 66 63 59 byte

For i=0To[A1]:?Space([A1]-i)"O"Space(2*i)"O"String(i,vbCr):Next

Risparmiato 29 byte in totale grazie a Taylor Scott

Questo deve essere eseguito nella finestra immediata di VBA e stampare il risultato nello stesso.

Espanso / formattato, diventa:

For i=0 To [A1]
   Debug.Print Space([A1]-i) & "O" & Space(2*i) & "O" & String(i,vbCr)
Next

(Si scopre che la concatenazione in un comando di stampa è automatica senza operatore.)

— Ingegnere Toast
fonte
b & s &Avviso spazi!
— Calcolatrice
Ho provato ed è andato storto la prima volta. Tornando indietro, mi sono reso conto che si espanderà b &s &Stringma non b&s&String. Inoltre, all'inizio pensavo che volessi usare la Spacefunzione che avrei dovuto assolutamente avere e che alla fine ha salvato più byte.
— ingegnere Toast il
Si può condensare for i=0 To ve debug.? bdi for i=0To ve Debug.?b, rispettivamente, per -2byte. E solo per questo sai, il consenso della comunità è che per le lingue con formattazione automatica, puoi contare prima che venga formattato automaticamente, il che significa che dopo aver apportato queste modifiche dovresti avere un conteggio dei byte di 85 byte
— Taylor Scott
In una seconda occhiata, si tratta di un frammento, non di una funzione o subroutine; quindi non è una soluzione valida. Credo che potresti risolvere questo problema convertendolo in una funzione finestra immediata VBA di Excel e prendendo input da [A1]( v=[A1]) Inoltre, non penso che tu abbia effettivamente bisogno della svariabile.
— Taylor Scott,
1
@TaylorScott Sembra un evidente miglioramento in retrospettiva, ma non sapevo che la concatenazione non richiedesse un operatore nella finestra immediata. Questo mi farà risparmiare qualche byte in futuro. Ho dovuto aggiungere ;a alla fine del comando di stampa, tuttavia, perché continuava ad aggiungere un'interruzione di riga aggiuntiva per impostazione predefinita. Grazie!
— ingegnere Toast l'
2

05AB1E , 18 13 byte

ÝηRO«ð×'O«ζ»

Provalo online!

Ý                # [0..n]
 €LRO            # [0.sum(), 0..1.sum(), ..., 0..n-1.sum(), 0..n.sum()]
     «          # Mirror image the array [0, 0..n.sum(), 0]
       ð×'O«     # Push that many spaces with an O appended to it.
            .B   # Pad small elements with spaces to equal largest element length.
              ø» # Transpose and print.
— Urna di polpo magico
fonte
1

Gelatina , 17 16 byte

‘Ḷ+\Ṛ⁶ẋ;€”Om0z⁶Y

Provalo online!

Come?

‘Ḷ+\Ṛ⁶ẋ;€”Om0z⁶Y - Main link: v         e.g. 3
‘                - increment: v+1            4
 Ḷ               - lowered range             [0,1,2,3]
  +\             - reduce with addition      [0,1,3,6]
    Ṛ            - reverse                   [6,3,1,0]
     ⁶           - a space                   ' '
      ẋ          - repeat (vectorises)       ['      ','   ',' ','']
       ;€        - concatenate each with
         ”O      -     an 'O'                ['      O','   O',' O','O']
           m0    - concatenate reflection    ['      O','   O',' O','O','O','O ','O   ','O      ']
             z⁶  - transpose with space fill ['   OO   ','  O  O  ','        ',' O    O ','        ','        ','O      O']
               Y - join with line feeds      ['   OO   \n  O  O  \n        \n O    O \n        \n        \nO      O']
                 - implicit print
— Jonathan Allan
fonte
1

PHP, 76 byte

for(;$argn>=0;$s.="  ")echo($r=str_repeat)("
",$i++),$r(" ",$argn--),o,$s,o;

Esegui echo <v> | php -nR '<code>'o prova online .

loop $argngiù dall'ingresso 0e $idal 0;
stampa - in quell'ordine - in ogni iterazione

  • $i newline (nessuno nella prima iterazione)
  • imbottitura sinistra: $argnspazi
  • palla sinistra: o
  • imbottitura interna: 2*$ispazi
  • palla a destra: o
— Titus
fonte
1

V , 23 19 byte

2éoÀñYço/^2á O
HPJ>

Provalo online!

Spiegare

2éo            " Insert two 'o's
   Àñ          " <Arg> times repeat
     Y         " Yank the current (top) line.  This is always '\s*oo'
      ço/      " On every line that matches 'o'
         ^     " Go to the first non-whitespace character (the 'o')
          2á   " Append two spaces (between the two 'o's
             O " Add a blank line on top of the current one
H              " Go to the first line
 P             " Paste in front ('\s*oo')
  J            " Join this line with the blank line immediately after it
   >           " Indent once
— nmjcman101
fonte
1

JavaScript (ES6), 87 byte

f=
n=>' '.repeat(n+1).replace(/./g,"$`#$'O$`$`O").replace(/ *#/g,s=>[...s].fill``.join`
`)
<input type=number min=0 oninput=o.textContent=f(+this.value)><pre id=o>
Espandi frammento

Soluzione non ricorsiva. Il requisito di indicizzazione era fastidioso, sia nella soluzione ricorsiva di 62 byte (che non so se si tradurrebbe in una porta Retina più corta) sia nella precedente:

f=n=>~n?` `.repeat(n)+`OO`+f(n-1).replace(/^ *O/gm,`
$&  `):``
— Neil
fonte
0

Impilato, 67 63 byte

args 0#1+:@x:>{!n x\-1-' '*'O'+n 2*' '*+'O'+x 1-n!=n*LF*+out}"!

Tentativo iniziale, 67 byte

args 0# :@v 1+2*:>[:v:+1+\-2/*' '*'O'+''split]"!fixshape tr rev out

Programma completo. Genera qualcosa di simile:

('O'
 ' ' 'O'
 ' ' 'O'
 'O')

Che è imbottito, trasposto, invertito ed emesso.

— Conor O'Brien
fonte
0

Lotto, 163 byte

@set l=@for /l %%i in (1,1,%1)do @call
@set s=
%l% set s= %%s%%
@set t=
%l%:c&for /l %%j in (2,1,%%i)do @echo(
:c
@echo %s%O%t%O
@set s=%s:~1%
@set t=  %t%
— Neil
fonte
0

Rubino, 52 byte

->x{(0..x).map{|a|$><<$/*a+' '*(x-a)+?O+' '*a*2+?O}}

Nessuna nuova riga finale (consentita dalle regole: " al massimo una nuova riga finale ")

— GB
fonte
0

AHK, 93 byte

m=0
n=1
f=%1%-1
Loop,%1%{
r=%r%{VK20 %f%}O{VK20 %m%}O{`n %n%}
m+=2
n++
f--
}
FileAppend,%r%,*

Se riuscissi a capire come fare la matematica ripetendo i tasti, sarebbe fantastico.
- VK20equivale a uno spazio
- FileAppendrestituisce stdoutse il nome file è*

— Ingegnere Toast
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.