Antecedentes
El verano ha terminado en el hemisferio norte, y muchos de nosotros extrañamos el sol, las playas, las olas del océano ... Este desafío tiene como objetivo animarlos recordándoles el mar.
El reto
Aquí está el mar:
** ** ** ** **
**** **** **** **** ****
***** ***** ***** ***** *****
** ** ** ** ** ** ** ** ** **
** ** ** ** ** ** ** ** ** **
** ****** ****** ****** ****** ****
El mar está hecho de 5 veces este patrón de onda:
**
****
*****
** **
** **
* *****
Tenga en cuenta que el patrón tiene 16 caracteres de longitud y el mar tiene 5 veces este patrón = 80 caracteres de longitud.
Que puede imprimir en un terminal usando esta línea de comando:
perl -e 'print " ** \n **** \n ***** \n ** ** \n ** ** \n* *****\n"'
O este :
perl -e 'print " "x12, "*"x2, " "x2, "\n", " "x8, "*"x4, " "x4, "\n", " "x5, "*"x5, " "x6, "\n", " "x3, "*"x2, " "x3, "*"x2, " "x6, "\n", " "x1, "*"x2, " "x6, "*"x2, " "x5, "\n", "*"x1, " "x10, "*"x5, "\n"'
(El segundo debería facilitarle obtener el patrón exacto)
Su tarea es mostrar el mar en una terminal y hacer que parezca que las olas se mueven hacia la derecha: debe desplazarse hacia la derecha a una velocidad de 1 carácter cada 100 ms (= 10 veces cada segundo). No se debe imprimir ningún carácter después de la columna 80, pero a medida que desaparece la onda más a la derecha, aparece una nueva a la izquierda.
Aquí hay un ejemplo de salida:
tiempo = 0.0s
** ** ** ** **
**** **** **** **** ****
***** ***** ***** ***** *****
** ** ** ** ** ** ** ** ** **
** ** ** ** ** ** ** ** ** **
** ****** ****** ****** ****** ****
tiempo = 0.1s
** ** ** ** **
**** **** **** **** ****
***** ***** ***** ***** *****
** ** ** ** ** ** ** ** ** **
** ** ** ** ** ** ** ** ** **
*** ****** ****** ****** ****** ***
tiempo = 0.2s
* ** ** ** ** *
**** **** **** **** ****
***** ***** ***** ***** *****
** ** ** ** ** ** ** ** ** **
** ** ** ** ** ** ** ** ** **
**** ****** ****** ****** ****** **
tiempo = 0.3s
** ** ** ** **
**** **** **** **** ****
***** ***** ***** ***** *****
** ** ** ** ** ** ** ** ** **
** ** ** ** ** ** ** ** ** **
***** ****** ****** ****** ****** *
tiempo = 0.4s
** ** ** ** **
* **** **** **** **** ***
***** ***** ***** ***** *****
** ** ** ** ** ** ** ** ** **
** ** ** ** ** ** ** ** ** **
****** ****** ****** ****** ******
Por supuesto, cada salida debe reemplazar a la anterior.
Puede ejecutar este código en un terminal Unix para ver cómo debería verse con la animación:
perl -M5.010 -MTime::HiRes=sleep -E '@arr=([($")x12,($n="*")x2,($")x3],[($")x8,($n)x4,($")x4],[($")x5,($n)x5,($")x6],[($")x3,($n)x2,($")x3,($n)x2,($")x6],[($")x1,($n)x2,($")x6,($n)x2,($")x5],[($n)x1,($")x10,($n)x5]);while(++$j){for$i(0..5){for$k(0..15) {$out[$i][16*$_+$k]=$arr[$i][($k-$j)%16]for 0..4}}say"\e[H",$/,join$/,map{join"",@$_}@out;sleep 0.1}'
(Tenga en cuenta que este código no está muy bien desarrollado: solo lo hice lo suficientemente compacto como para que sea conveniente ejecutarlo en una terminal).
Criterio ganador
Esto es codegolf, por lo que gana el código más corto en bytes.
Respuestas:
MATL ,
4140 bytesEjemplo de ejecución:
¡O pruébalo en MATL Online! (la velocidad real puede depender de la carga del servidor).
Cómo funciona
fuente
JavaScript (ES6) + HTML,
151143 + 10 =161153 bytesfuente
a
?a
contiene el patrón de onda codificado en binario y se gira en cada cuadro. Por lo tanto, no se puede codificar: debe almacenarse en una variable.HTML + CSS, 70 +
181175 = 245 bytesHace uso de
text-shadow
,rtl
animaciones de texto y de fotogramas clave CSS.fuente
C #
450444425417 Bytes399 sin
using System.Linq;
pero estoy seguro de que sería trampa ...Editar: 25 bytes guardados gracias a @Cyoce
Golfizado:
Sin golf:
fuente
(a)=>
. Ywhile(true)
puede serfor(;;)
s
lambda, creo que puedes eliminar el{}
yreturn
\r
destring.Join
(al menos en Windows funciona, aunque no lo probó con Mono) También puede guardar 1 byte al ponerlop++
en elfor
bucle de esta manerafor(;;p++)
if (p==16)...
), también puede colocarla en el encabezado del bucle for de esta manerafor(;;p=++p%16)
. Ahorre 1 byte más declarandop
en el bucle (for(int p=0;;p=++p%16)
)V,
989773 bytes¡Gracias a @ nmjcman101 por guardar 24 bytes!
Esto contiene muchos no imprimibles, así que aquí hay un xxd hexdump:
Editar
Usado en
y$
lugar de<C-v>$y
Muchos cambios
{
y}
para guardar algunos bytesò
lugar de registros para crear el bucle infinito (por alguna razón tengo que incluir unò
al final para que funcione)*
en la parte inferiorMini-Explicación
Estoy usando
<alt-n>
para crear copias de cadenas. Por ejemplo,<alt-5>*
(esto pareceµ5
) hace5
copias de*
en modo de inserción. Esto me pareció más corto que copiar la cadena y usar una expresión regular para hacer los reemplazos necesarios. Después de crear una ola, la pego para crear las otras olas. Finalmente, realizo un ciclo recursivoò
para crear el ciclo infinito (con un retraso de100ms
).GIF
La mayor parte del código está dedicado a crear la ola, por lo que todavía estoy intentando jugar golf. Tenga en cuenta que este código no funcionará en TIO ya que TIO solo genera la salida una vez que el código ha finalizado la ejecución. Así que aquí hay un gif (perdón por la baja calidad, tuve que usar un sitio web para convertir un
.mov
a.gif
, también el>_
que sigue apareciendo a la derecha es el ícono de Terminal en el muelle de mi Mac):fuente
5j
(en el contexto de$<C-V>5j
) podría ser}
, yp
después de eso|
debería ser unP
que reparará la estática*
en la parte inferior izquierda.qm[CODE]@mq@m
al final con soloò[CODE]
. El código entre seò
repetirá hasta que se rompa (de manera similar a su macro), y al final de un programaò
se cierra implícitamente.Lote, 424 bytes.
Algunas líneas tienen espacios finales. Requiere un terminal estándar de 80 columnas. El momento no es muy preciso, pero es lo mejor que puedes hacer en Batch.
fuente
Raqueta
395374373367364351 bytesUtiliza una biblioteca externa para borrar la pantalla
Editar: guardado 21 bytes al no definir
w
e incluir la función.Edit2: guardado 1 byte eliminando un espacio.
Edit3: guardado 6 bytes cambiando el nombre
loop
ap
, gracias @rnso!Edit4: colocando la subcadena en dejar de guardar 3 bytes.
Edit5: Eliminar
#lang racket
, que no es necesario en el intérprete.Golfizado: 351 bytes
Desplazamiento (sin borrar): 272 bytes
Sin golf:
fuente
simplescreenrecorder
conavconv
convertir mp4 a GIF.rotmul
realmente se tomów
como parámetro.PowerShell 3.0,
183182173 bytesRequiere PS 3.0 para operadores de desplazamiento binario. ¡Reducido a 173 bytes con la ayuda de AdmBorkBork !
fuente
.PadLeft
mover la$o
declaración a la[convert]
llamada y eliminar las comillas alrededor de los números en las-replace
operaciones. Tefor(){0..5|%{("{0:D16}"-f+[Convert]::ToString(([uint16]$o=$w[$_]),2))*5-replace0,' '-replace1,'*'
+
en el"{0:D16}"-f+[Convert]
? No funciona sin él, pero no puedo entender lo que hace.[convert]::ToString()
devuelve una cadena. Las+
fuerzas de un molde a una[int]
para que los-f
recoge el tipo de parámetro correcto para laD16
que trabajo.+'1'
como una operación aritmética válida sin primer sumando, vaciadosstring
aint
y devuelve un resultado? ¡Gran Scott!Bash + Coreutils
172148 bytes24 bytes guardados gracias a @zeppelin , muchas gracias
La primera línea descomprime el siguiente patrón formado por 6 ondas consecutivas:
Luego, el bucle desliza una ventana de 80 bytes de ancho a través de ese patrón.
fuente
*> <> ,
251250251 bytes (no competitivos)Nota:
"H;0["
se supone que tiene ascii27
después[
.Pruébalo aquí! (establecer retraso a 0 ms)
No puedo creer que terminé haciendo esto con éxito. Utiliza las instrucciones
I
yD
, que aumentan o disminuyen la pila seleccionada. Esto demuestra que probablemente sea posible hacer esto en puro> <> (menos el sueño) o una respuesta competitiva *> <>, aunque probablemente sea mucho más difícil de hacer.La versión del intérprete en línea es diferente simplemente para borrar la salida utilizando un retorno de carro.
Esto es porque no compitiendo los
I
,D
,C
, yR
las instrucciones son más jóvenes que el reto. Probablemente esto sea posible sin esas instrucciones, pero sería muy difícil / largo.Editar: en realidad logré eliminar un byte, pero también noté que medí el tamaño incorrectamente, así que en realidad gané un byte.
Haré todo lo posible para desglosar los pasos y explicar lo que está sucediendo aquí ...
Explicación
Tabla de contenido
Inicialización
Aquí construimos las 6 líneas que construyen las olas. Necesitamos repetir cada cuerda 5 veces para tener la longitud correcta.
Comenzamos con 6 de estos, uno para cada línea de la onda:
Y entramos en el bucle principal después de la inicialización
09.
.Copiar pila actual 4 veces
Esta es una función simple que simplemente toma la pila actual y la copia 4 veces. Entonces "a" se convertiría en "aaaaa".
Copiar pila
Esto copia la pila actual, agregando la copia a la pila actual.
Preparar
Saltará la inicial
<
e invertirá la primera línea para que se convierta,l:&0v
ya que es el orden en que se ejecuta después de que<
cambia la dirección de la IP.De aquí en adelante, la longitud se denominará como
n
y0
comoi
.Lazo
Limpiar
Bucle principal
Aquí es donde el código se ejecuta para siempre, redibujando constantemente las olas entre 100 ms duerme.
Preparar
Lazo
fuente
PHP, 128 bytes
No puede animar más de una línea, pero se desplaza.
Agregue
,0
a la matriz una línea vacía entre iteraciones. Corre con-r
.fuente
Mathematica, 213 bytes
No veo ninguna forma de jugar golf en el patrón de onda en Mathematica que no sea simplemente comenzar con una lista de cadenas para cada línea. Inicializo
i
ser0
y programo una tarea para incrementarla cada0.1
segundo. MeDynamic
aliado mostrará el resultado de lo siguiente:StringRepeat
cada línea 5 veces.Characters
.RotateRight
cada lista de caracteres pori
.Grid
.fuente
C (unix),
231191 bytesEsto solo funcionará en entornos Unix. Además, disculpe el hecho de que el sueño solo acepta números enteros ... por lo que en realidad demora 1 segundo entre fotogramas.
Versión sin golf:
Versión de golf:
fuente
Javascript (ES6),
152147145 bytesfuente
setInterval(a=>{...},100,6)
y 4 más conf+=" *"[[...][a]&1<<(i+x)%16]
.Perl 6,
140138137123120 bytesViejas soluciones:
fuente
Python 3,
240239230 bytes-1 byte gracias a @redstarcoder
-9 bytes gracias a @PascalvKooten
fuente
print("\x1b[0;H")
También funciona para mí por -1 byte.' **'
con' '*13+'**'
y puede tener sangrías de 1 carácter mientras tanto, no es necesario que sea de 4 caracteres.Raqueta 295 bytes
Sin golf:
Pruebas:
Salida:
(Esta visualización del archivo gif es más lenta que la salida real).
fuente
Python 2,
207202 bytesPor lo general, soy un desarrollador de C #, por lo que es posible que todavía no esté completamente desarrollado ...
fuente
C #, 327 bytes
Más o menos una versión portada de mi solución en Python ...
fuente
Perl, 110 bytes
Requiere
-E
sin costo adicional. Este contiene caracteres no imprimibles.Cree los datos anteriores utilizando el siguiente hexdump reversible. Ejecutar
xxd -d > sea.pl
en un linux o terminal compatible, pegue el siguiente y presione Ctrl+ d, luego ejecuteperl -E "$(cat sea.pl)"
.Uso
Para copiar / pegar fácilmente, utilice lo siguiente:
Explicación
Una solución bastante sencilla que almacena la onda como una cadena al principio, que se
unpack
edita en binario, cada sección se quintuplica, los0
s se convierten en espacios y1
s se convierten en*
s. Ahora tenemos la cadena completa, por lo que ingresamos unredo
bucle que imprime la cadena completa, luego esperamos por .1 segundos y para cada línea de la cadena, movemos el último carácter al comienzo de la cadena.fuente
Mathematica 171 Bytes
La onda en sí es información, por lo que estoy almacenando una versión comprimida de toda la onda en mi código. Puedo almacenar una sola onda de forma mucho más compacta ya
\fð߀ᣀ恠耟
que utilizo su representación binaria, pero la sobrecarga de conteo de caracteres de descompresión es demasiado alta *.Aquí está el código:
Aquí está el código que usé para crear la versión comprimida de los datos de la onda:
Aquí está el código que hubiera preferido usar para almacenar datos binarios repetidos comprimidos como esta onda:
Como puede ver, la sobrecarga para volver a convertir los datos comprimidos en una cadena es demasiado costosa para este problema en particular, aunque una sola onda se puede almacenar de esta manera con 7 caracteres UTF y 15 bytes.
Aquí estaba el código para determinar la secuencia de caracteres UTF para almacenar una sola onda (s como arriba).
fuente
Rubí
269217189185 Bytes-28 Bytes gracias a @manatwork
-5 Bytes gracias a @ropata
Normal
Golfed
fuente
do … end
→{ … }
y elimine las nuevas líneas después{
y antes}
; eliminar el espacio entresystem
y su parámetro; eliminar el,
último elemento del literal de matriz posterior;.each
→.map
y elimine el espacio entre este y su bloque de código; quitar el espacio en frente deputs
;0..80
→0,80
(esto también es un error ya que la expresión da como resultado una cadena larga de 81 caracteres);p=p+1==16?0: p+1
→p=-~p%16
.do … end
→{ … }
, todavía se necesita laloop
palabra clave. Este es el más corto que obtengo: pastebin.com/cg3gxnm4b=' '
(5 espacios en blanco) en la parte superior y luego cambiando la expresión de salida a' '*12+'** ', ' '*8+'**** ',b+'***** '+b,' ** ** '+b,' ** **'+b,'*'+b+b+'*****'
... (¡pero SE no muestra espacios repetidos correctamente en este comentario!)HTML + JS + jQuery, 10 + 233 = 243 bytes
El JavaScript simplemente cambia cada fila por 1 y cambia el texto cada 100 ms.
fuente