Imprima un arco de números ascendentes / descendentes

28

Supuse que un "arco" era la mejor manera de describir este patrón de números:

1234567887654321
1234567  7654321
123456    654321
12345      54321
1234        4321
123          321
12            21
1              1

Definida formalmente, cada línea consta de los números del 1 al 1 9-n, los (n-1)*2espacios y los números del 9-n1 al 1 (donde nestá la línea actual).

Su tarea es escribir, utilizando el código más corto posible, un pequeño script / programa que imprima el patrón anterior sujeto a las siguientes restricciones:

  1. No puede codificar todo el patrón. Solo puede codificar una sola línea del patrón como máximo.
  2. Su programa debe imprimir una nueva línea (cualquier combinación de \no \r) al final de cada línea.

¡En sus marcas, listos, fuera!

code-golf  ascii-art  number  kolmogorov-complexity 
— Nathan Osman
fuente
1
Un pequeño truco adicional estaría disponible con la línea superior, 123456787654321ya que equivale a 11111111^2 ;-)
— Egor Skriptunoff
3
@EgorSkriptunoff 11111111^2 == 123465787654321 != 1234567887654321(aviso repetido 8)
— Bob
Esto es una especie de inverso de Imprimir este diamante
— Peter Taylor
66
Se parece más bien a una cortina .
— Volatilidad

Respuestas:

22

Pitón 2, 65 55 53 51

s=12345678
while s:r='%-8d'%s;print r+r[::-1];s/=10

Acortado usando algunas de las ideas de ugoren .

— Volatilidad
fuente
Heh, sabía que había margen de mejora: P
— Nathan Osman
2
Se puede ahorrar mucho s=s[1:]por lazo ywhile s:
— ugoren
9

APL (18) 

k,⌽k←↑↑∘(1↓⎕D)¨⌽⍳8

Explicación:

  • 1↓⎕D: la cadena de dígitos ("0123456789") menos su primer elemento
  • ↑∘(1↓⎕D)¨⌽⍳8: seleccione los primeros [8..1] caracteres ('12345678', '1234567' ...)
  • ↑: formato como matriz (rellenando los caracteres no utilizados con espacios en blanco)
  • k,⌽k←: almacenar ky mostrar kseguido por la duplicación vertical dek
— marinus
fuente
4

Ruby: 61 50 caracteres

s="87654321";s.chars{|c|puts s.reverse+s;s[c]=" "}

Ejecución de muestra:

bash-4.2$ ruby -e 's="87654321";s.chars{|c|puts s.reverse+s;s[c]=" "}'
1234567887654321
1234567  7654321
123456    654321
12345      54321
1234        4321
123          321
12            21
1              1
— hombre trabajando
fuente
4

Befunge - 3 x 18 = 54

Sentí que tenía que hacer algo con befunge, ha pasado mucho tiempo desde la última vez que lo usé. Este problema se sintió más apropiado para el idioma.

Es terriblemente lento debido al ciclo de impresión que toma alrededor de 8 acciones por personaje (los estilos de conteo difieren). 

80v >#v"12345678"<
>5 *^ >,#$:_$:1-:v
^2< 0p0+7\*48\_@#<
— shiona
fuente
4

JavaScript, 71

s='1234567887654321',i=10;while(--i)console.log(s=s.split(i).join(' '))
— steveworley
fuente
s="1234567887654321";for(i=10;--i;)console.log(s=s.split(i).join(" "))para 70 personajes, @SteveWorley
— WallyWest
3

C, 83 caracteres

main(a,b,n){
    for(a=12345678,n=1e8,b=n-a-1;a;a/=10)
        printf("%-8d%8d\n",a,b),
        b%=n/=10;
}
— Ugoren
fuente
3

Pitón 2, 75 62

No superará la respuesta de Volatility, pero aquí hay otro enfoque que utiliza cadenas mutables de python ( bytearray):

s=bytearray('1234567887654321')
for i in range(8):s[8-i:8+i]=i*'  ';print s

Editar

Encontré una versión más corta, usando str.replace:

s='1234567887654321'
for c in s[8:]:print s;s=s.replace(c,' ')
— Baptiste M.
fuente
3

Perl, 41

-Einterruptor más Total de caracteres en la línea de comando: 50

requiere al menos perl5, versión 10.

perl -E'say@!=1..8-$_,$"x(2*$_),reverse@!for-0..7'
— amon
fuente
Yo diría que esto es 42, debido al hecho de que el aspecto estándar -Ees una adición de un byte al programa.
— Timtech
3

Mathematica 92 85 67 54 51

Método n. ° 1 : (54 caracteres) Crea una matriz usando la fila n. °, n. ° col. Y la distancia desde el borde izquierdo-derecho.

Grid@Array[If[#2<9,#2,17-#2]/.x_/;x+#>9:>" "&,{8,16}]

Método # 2 : (67 caracteres) Alcanzar rangos de acortamiento.

Print@@@Table[Join[k = PadRight[Range@i, 8, " "], Reverse@k], {i, 8, 1, -1}];

Método # 3 : (85 caracteres) Llena selectivamente cada fila de una matriz.

Comience con la lista de 8 caracteres espaciales. Reemplace las posiciones 1 y 16 con "1"; reemplace "2" en las posiciones 2 y 15, etc.

p = 0; q = 16;
Print @@@Reverse@Rest@NestList[ReplacePart[#, {++p -> p, q-- -> p}]&,Array[" "&,q], 8];

Método 4 : (86 caracteres) Vacíe selectivamente cada fila de una matriz.

p=8;q=9;
Print@@@NestList[ReplacePart[#,{p---> " ",q++-> " "}]&,Join[k=Range@8,Reverse@k],7];

Método # 5 : Usando cadenas (92 caracteres)

p=8;s="12345678";
Print[#,StringReverse@#]&/@NestList[StringReplace[#,ToString@p-- ->  " "]&,s,7];
— DavidC
fuente
¡Ese nuevo es elegante! Volvería a hacer +1 si pudiera. :-) por cierto, puede soltar ()y reemplazar #1con #:Grid@Array[If[#2<9,#2,17-#2]/.x_/;x+#>9:>" "&,{8,16}]
— Mr.Wizard
Gracias por los consejos. Sí, a Arrayveces puede hacer buenas tablas sin tener que agregar iteradores.
— DavidC
3

PHP, 68

(Inspirado por la respuesta de HamZa)

for($n=8;$n;$r[]=$n--)echo str_replace($r," ","1234567887654321\n");

Se basa en el hecho de que str_replace de PHP puede aceptar una matriz para búsqueda y una cadena para reemplazar, reemplazará cada elemento de la matriz con la cadena dada. Después de cada iteración, el número actual se agrega a la matriz de búsqueda, eliminándolo del siguiente ciclo.

Ejemplo del código en acción: http://ideone.com/9wVr0X

— Señor llama
fuente
jeje bonito +1
— HamZa
Sin embargo, no parece poner el número correcto de espacios en el medio
— nathan hayfield
@nathanhayfield: ¿Cómo es eso? Primera línea tiene 0 espacios, segundo tiene 2, a continuación, 4, 6, 8, etc.
— Sr. Llama
no cuando lo ejecuté
— nathan
Eso es porque la salida no estaba envuelta en <pre>etiquetas. Cuando se interpreta como texto html, los espacios se contraen y las líneas nuevas se ignoran, pero si marca la fuente verá lo contrario.
— Sr. Llama
3

Marbelous 165

@0
08
>0
LN
--
@0
:LN
}0}0}0}0
..SAPSSD0A
{0
:PS
}0
~~09
..//
<<@0
\\>0
&0//
--@1
@020
&0/\&0
@1
:SA
@0
}0
>0!!
--00@1
@0++//
+O/\@1
+O
:SD
}0@0
\\>0\/
--/\+O
@0..+O

Pseudocódigo:

MB():
    for x in 8..1:
        LN(x)
LN(x):
    SA(x)
    PS(x)
    SD(x)
    print "\n"
PS(x):
    print " "*(8-x)*2
SA(x):
    for n in 1..x:
        print n
SD(x):
    for n in x..1:
        print n
— Sparr
fuente
2

Python 2.x - 73 65 63 61 caracteres

c=1;s='87654321'
while c<9:print s[::-1]+s;s=' '*c+s[c:];c+=1
— TerryA
fuente
2

PHP, 76

for($i=9;$i>1;){$r[]=$i--;echo str_replace($r,' ','1234567887654321')."\r";}
— HamZa
fuente
2

K, 28

-1_a,'|:'a:8$'{-1_x}\,/$1+!8

.

k)-1_a,'|:'a:8$'{-1_x}\,/$1+!8
"1234567887654321"
"1234567  7654321"
"123456    654321"
"12345      54321"
"1234        4321"
"123          321"
"12            21"
"1              1"

Puedes generalizarlo por 36: {-1_a,'|:'a:(#*m)$'m:{-1_x}\,/$1+!x}

k){-1_a,'|:'a:(#*m)$'m:{-1_x}\,/$1+!x} 5
"1234554321"
"1234  4321"
"123    321"
"12      21"
"1        1"
q)k){-1_a,'|:'a:(#*m)$'m:{-1_x}\,/$1+!x} 15
"123456789101112131415514131211101987654321"
"12345678910111213141  14131211101987654321"
"1234567891011121314    4131211101987654321"
"123456789101112131      131211101987654321"
"12345678910111213        31211101987654321"
"1234567891011121          1211101987654321"
"123456789101112            211101987654321"
"12345678910111              11101987654321"
"1234567891011                1101987654321"
"123456789101                  101987654321"
"12345678910                    01987654321"
"1234567891                      1987654321"
"123456789                        987654321"
"12345678                          87654321"
"1234567                            7654321"
"123456                              654321"
"12345                                54321"
"1234                                  4321"
"123                                    321"
"12                                      21"
"1                                        1"
— tmartin
fuente
2

Javascript, 67 caracteres

Inspirado por la respuesta de steveworley (comentaría si pudiera):

Fragmento de código

a='1234567887654321\n',b='',c=10;while(--c)b+=a=a.split(c).join(' ')
<a href="#" onclick="javascript:document.getElementById('output').innerHTML = b;">Display</a>
<pre id="output">...</pre>
Expandir fragmento

La presencia de la última línea nueva sigue las reglas.

actualización: corte 2 caracteres eliminando paréntesis (precedencia del operador) y 1 eliminando un espacio innecesario

Parecía que me estaba molestando, porque no importa cuántas formas diferentes traté de acortar o simplificar al descodificar un segmento de código, la longitud se mantuvo igual hasta que dejé que se aplicara la regla "Creo que esto cuenta" que se escribe a continuación.

(Si la impresión cuenta como lo que vuelve cuando esto se ejecuta en la consola de Chrome)

— Sophiα2329
fuente
No se parece a la otra respuesta, los números no están alineados en la columna de la derecha.
— AL
@AL La alerta no es necesaria si lee qué salida sale de la conson por cierto.
— Sophiα2329
Para alinear la columna derecha, debe haber 1 espacio en lugar de 2 en el argumento de cadena de combinación. Con 2 espacios, está alineado correctamente en la alerta del navegador basado en Chrome.
— Qwertiy
Actualicé su publicación (se debe aceptar la edición) para mostrar el resultado en un fragmento sin una alerta JS, solo se necesita un espacio en este caso.
— AL
2

Brainfuck: 542 bytes

-[----->+<]>--.+.+.+.+.+.+.+..-.-.-.-.-.-.-.>++++++++++.[->+++++
<]>-.+.+.+.+.+.+.+[-->+<]>++++..----[->++<]>-.-.-.-.-.-.-.>++++++++++.[->+++++
<]>-.+.+.+.+.+.[-->+<]>+++++....-----[->++<]>.-.-.-.-.-.>++++++++++.[->+++++
<]>-.+.+.+.+.--[--->++<]>--......-----[->++<]>-.-.-.-.-.>++++++++++.[->+++++
<]>-.+.+.+.-[--->++<]>--........++[-->+++<]>+.-.-.-.>++++++++++.[->+++++
<]>-.+.+.[--->++<]>--..........++[-->+++<]>.-.-.>++++++++++.[->+++++
<]>-.+.--[--->++<]>............[-->+++<]>++.-.>++++++++++.[->+++++
<]>-.-[--->++<]>..............[-->+++<]>+.
— NaCl
fuente
1

Mathematica , 59

61 usando mis propias ideas:

Grid[Clip[#~Join~Reverse@#&@Range@8,{1,9-#},{," "}]&~Array~8]

O 59, tomando prestado de la respuesta de David:

Grid@Array[Join[k=PadRight[Range[9-#],8," "],Reverse@k]&,8]
— Señor mago
fuente
Acabo de guardar 4 caracteres usando Grid, inspirado en su entrada.
— DavidC
1

R: 52

for(i in 8:1)cat(1:i,rep(" ",16-2*i),i:1,"\n",sep="")
— flodel
fuente
1

Haskell, 84

Un punto de partida para que alguien mejore:

mapM_ putStrLn[let l=take(8-i)"12345678"++replicate i ' 'in l++reverse l|i<-[0..7]]

La parte más probable sería l++reverse lliberar el punto, permitiéndonos deshacernos de la letdeclaración, pero podría encontrar que era ap, lo que requiere importaciones.

— shiona
fuente
1

PostScript: 105 caracteres

El manejo de cadenas no es fácil en PS pero puede generar un código relativamente simple:

0 1 7{(1234567887654321)dup
8 3 index sub(              )0 6 -1 roll 2 mul getinterval putinterval =}for

Una versión un poco más larga con 120 caracteres, pero puede generar diferentes arcos de números reemplazando el 8 al comienzo de la segunda línea con cualquier número en el rango de 1 a 9:

/D{dup}def/R{repeat}def/P{=print}def
8 D -1 1{1 1 index{D P 1 add}R pop 2 copy sub{(  )P}R D{D P 1 sub}R pop()=}for pop
— MrMRDubya
fuente
Es bueno ver que no soy el único que ama PostScript.
— AJMansfield
1

GoRuby 2.1

36 caracteres

8.w(1){|x|a=[*1..x].j.lj 8;s a+a.rv}

Sin golf

8.downto(1) do |x|
  a = [*1..x].join.ljust(8)
  puts a + a.reverse
end
— Patrick Oscity
fuente
1

K 20

{x,'|:'x:|x$,\$1+!x}    

q)k){x,'|:'x:|x$,\$1+!x}8    
"1234567887654321"    
"1234567  7654321"    
"123456    654321"    
"12345      54321"    
"1234        4321"      
"123          321"    
"12            21"    
"1              1"
— ppp
fuente
1

TSQL, 148

Editar: hasta 148 con la sugerencia de manatwork y ajustar a ORDER BY.

Legible:

WITH t AS(
    SELECT 1n, CAST(1 AS VARCHAR(MAX)) o
 UNION ALL
    SELECT n+1,o+CHAR(n+49)
    FROM t
    WHERE n<8
)
SELECT o  + SPACE(16-2*n) + REVERSE(o)
FROM t
ORDER BY 1 DESC

Golfizado:

WITH t AS(SELECT 1n,CAST(1AS VARCHAR(MAX))o UNION ALL SELECT 1+n,o+CHAR(n+49)FROM t WHERE n<8)SELECT o+SPACE(16-2*n)+REVERSE(o)FROM t ORDER BY 1DESC

Salida:

1234567887654321
1234567  7654321
123456    654321
12345      54321
1234        4321
123          321
12            21
1              1
— cómodamentedrei
fuente
1
Buena esa. ¿Pero podría publicarlo también en el formato en el que contó 153 caracteres? De todos modos, le sobran 2 caracteres utilizando numérico 1en lugar de cuerdas '1'donde inmediatamente casten varchar. Esto me da 149 caracteres: with t as(select 1n,cast(1as varchar(max))o union all select n+1,o+char(n+49)from t where n<8)select o+space(16-2*n)+reverse(o)from t order by o desc.
— manatwork
@manatwork: No pude reproducir el número 153, porque seguía bajando. Sin embargo, apliqué tu sugerencia. ¡Gracias!
— comfortableablydrei
1

Haskell, 79

r n x|x>n=' '|True=x
t="87654321"
main=mapM(putStrLn.(`map`("12345678"++t)).r)t

Esto funciona reemplazando los caracteres> n con ' ', donde los caracteres n provienen de "87654321" (que resulta ser la cola de la cadena para realizar la sustitución).

— Joey Adams
fuente
1

PHP: 61 caracteres (o 60 caracteres si reemplaza el \ n por una nueva línea ASCII real)

(Inspirado por la respuesta de GigaWatt y HamZa)

for($n=9;$n;$r[$n--]=" ")echo strtr("1234567887654321\n",$r);

http://ideone.com/FV1NXu

— bwoebi
fuente
1

PowerShell: 38

Código de golf

8..1|%{-join(1..$_+"  "*(8-$_)+$_..1)}

Tutorial

8..1|%{... }canalizar enteros de 8 a 1 en un bucle ForEach-Object.
-join(... )une la salida del código anidado en una sola cadena sin delimitadores.
1..$_emite enteros ascendentes de 1 al entero actual en el bucle.
+" "*(8-$_)agrega un doble espacio, multiplicado por la diferencia entre 8 y el entero actual, a la salida.
+$_..1agrega enteros, descendiendo del entero actual a 1, a la salida.

— Iszi
fuente
1

Javascript con lambdas, 147

(s="12345678")[r="replace"](/./g,i=>s[r](RegExp(".{"+(i-1)+"}$"),Array(i*2-1).join(" ")))[r](/\d{1,8} */g,m=>m+(Array(m%10+1).join(m%10+1)-m)+"\n")

Se puede verificar en Firefox.

— Qwertiy
fuente
1

CJam, 22 caracteres

No es una respuesta válida (ya que el lenguaje se desarrolló después de la pregunta), y tampoco la más corta, pero aquí va:

8,{S*_,9-~,:)\_2$W%N}%

Pruébalo en línea aquí

— Optimizador
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.