Intercalar números del 1 al n, con los mismos números invertidos

34

Una simple:

Tome un entero positivo n menor que 1000, y genere los enteros de 1 a n entrelazados con los enteros de n a 1 . Debe concatenar los números para que aparezcan sin delimitadores entre ellos.

Casos de prueba:

n = 1
11

n = 4
14233241

n = 26
12622532442352262172081991810171116121513141413151216111710189198207216225234243252261

n = 100
110029939849759669579489399210911190128913881487158616851784188319822081218022792378247725762675277428732972307131703269336834673566366537643863396240614160425943584457455646554754485349525051515052495348544755465645574458435942604161406239633864376536663567346833693270317130722973287427752676257724782379228021812082198318841785168615871488138912901191109299389479569659749839921001

Este es el por lo que gana el envío más corto en bytes en cada idioma. Se alientan las explicaciones.

Stewie Griffin
fuente

Respuestas:

16

JavaScript (ES6), 30 bytes

f=(n,k=1)=>n?f(n-1,k+1)+n+k:''

¿Cómo?

Esto es bastante sencillo, pero vale la pena señalar que la cadena se construye de la cola a la cabeza. Una cadena vacía al principio se agrega al final y permite que ocurra la coerción del resultado final a una cadena.

A continuación se detalla la recursividad de f(4):

f(4) =                                            // initial call
f(4, 1) =                                         // applying the default value to k
f(3, 2) + 4 + 1 =                                 // recursive call #1
(f(2, 3) + 3 + 2) + 4 + 1 =                       // recursive call #2
((f(1, 4) + 2 + 3) + 3 + 2) + 4 + 1 =             // recursive call #3
(((f(0, 5) + 1 + 4) + 2 + 3) + 3 + 2) + 4 + 1 =   // recursive call #4
((('' + 1 + 4) + 2 + 3) + 3 + 2) + 4 + 1 =        // n = 0 --> end of recursion
'' + 1 + 4 + 2 + 3 + 3 + 2 + 4 + 1 =              // final sum
'14233241'                                        // final result

Casos de prueba

Arnauld
fuente
10

Python 2 , 46 bytes

lambda n:''.join(`x+1`+`n-x`for x in range(n))

Gracias a ovs por 4 bytes

Pruébalo en línea!

Explicación:

lambda n:''.join(`x+1`+`n-x`for x in range(n))
lambda n:                                      # anonymous lambda taking one parameter n
                 `x+1`+`n-x`                   # `x` is repr(x) which is equivalent to str(x) for integers less than INT_MAX
                            for x in range(n)  # integers x in [0, n)
Mego
fuente
1
Dos bytes más en Python 3:f'{x}{n-~-x}'
L3viathan
2
@ L3viathan Esa es una nueva característica agregada en 3.6.
Mego
1
Python 3.6 no es Python 3?
L3viathan
66
lambda n:''.join('x+1'+'n-x'for x in range(n))para 46 bytes. (reemplace el 'en la lista de comprensión con backticks)
2017
66
@ovs oye, puedes escapar del backtick -> `\`x+1\``renders a`x+1`
Rod
8

-5 gracias a Ørjan Johansen

Haskell , 33 bytes

f n=do a<-[1..n];[a,n-a+1]>>=show

Pruébalo en línea!

bartavelle
fuente
3
(1) Una doexpresión es más corta que >>=más una lambda. (2) Sin embargo, el shows se puede combinar mediante el uso >>=show.
Ørjan Johansen
7

Bash , 25 bytes

printf %s`seq $1 -1 1|nl`

Pruébalo en línea!

Imprime la secuencia decreciente, las líneas numéricas aumentan y printf une las líneas

Delimitado por espacios, 20 bytes: seq $ 1 -1 1 | nl | xargs

marcom
fuente
si eso no es aceptable, puedo cambiarlo por seq $1 -1 1|nl|tr -d ' \n\t'8 bytes más
marcosm
1
El envío de 20 bytes no es válido. Mi voto es por el envío de 25 bytes.
Trauma digital
Como señaló Digital Trauma, la solución de 20 bytes no es válida.
Erik the Outgolfer
time printf %s'seq 1000000 -1 1|nl'; grep name /proc/cpuinfo real 0m7.985s user 0m6.092s sys 0m0.392s model name : Intel(R) Pentium(R) D CPU 3.00GHz model name : Intel(R) Pentium(R) D CPU 3.00GHz
marcosm
7

R, 35 bytes

n=scan();cat(rbind(1:n,n:1),sep="")

Pruébalo en línea

rbind(1:n,n:1)crea una matriz de 2 filas con 1 a n en la primera fila yn a 1 en la segunda. La catfunción colapsa esta matriz, leyendo cada columna.

usuario2390246
fuente
1
Tenga en cuenta que esto solo funciona en modo interactivo y requiere que el usuario ingrese nen la línea de comando (en lugar de pasar por stdin).
shadowtalker
@ssdecontrol Sí, creo que eso generalmente está permitido, pero soy bastante nuevo aquí, podría estar equivocado.
user2390246
Creo que es generalmente aceptable, pero NB, para ejecutarlo correctamente en TIO, debe poner las entradas en el campo de pie de página (¡y siempre es bueno incluir un enlace!) Tio.run/nexus/…
Giuseppe
6

05AB1E , 6 5 bytes

Se guardó un byte usando el nuevo intercalado incorporado como lo sugiere rev

LÂ.ιJ

Pruébalo en línea!

Explicación

L        # range [1 ... input]
 Â       # create a reversed copy
  .ι     # interleave the lists
    J    # join
Emigna
fuente
Un usuario con el nombre de rev sugerido LÂ.ιJ.
Jonathan Frech
@JonathanFrech: Sé que el consenso ahora es que podemos usar características más nuevas que el desafío, pero generalmente dudo en editar las respuestas antiguas porque una nueva integrada completa el desafío mejor. Hay tantas respuestas en todas que podrían mejorarse de esa manera :)
Emigna
Bueno, yo solo era el mensajero; @rev posible debe publicar su propia respuesta.
Jonathan Frech
@ JonathanFrech: No lo dije como un reproche. Rev lo hizo correctamente cuando sugirió la edición, ya que es mejor editar una respuesta existente que publicar una nueva cada vez que se realiza una nueva función. Realmente debería mejorar en la fijación de respuestas antiguas, al menos cuando se hacen sugerencias.
Emigna
4

CJam , 10 bytes

ri,:)_W%]z

Pruébalo en línea!

Explicación

ri   e# Read input and convert to integer N.
,    e# Turn into range [0 1 ... N-1].
:)   e# Increment to get [1 2 ... N].
_W%  e# Duplicate and reverse the copy.
]    e# Wrap both in an array to get [[1 2 ... N] [N ... 2 1]]
z    e# Transpose to get [[1 N] [2 N-1] ... [N-1 2] [N 1]]
     e# This list is printed implicitly at the end of the program,
     e# but without any of the array structure (so it's essentially flattened,
     e# each number is converted to a string and then all the strings
     e# are joined together and printed).
Martin Ender
fuente
4

Ruby , 29 bytes

->n{n.times{|x|$><<x+1<<n-x}}

Explicación:

->n{n.times{|x|                # x in range [0..n-1]
               $><<            # output on console
                   x+1<<n-x}}  # x+1, then n-x

Pruébalo en línea!

GB
fuente
4

Espacio en blanco , 71 bytes

   
 
 	
		 
 			
  
 
	   	
	    
 	
 	 
	 
 	
 	   	
	  	 
 
	 	

 


Pruébalo en línea!

Explicación

sssn  ; push 0 - seed the stack with 0 (this will be our 1->n counter, a)
sns   ; dup
tntt  ; getnum - read n (stored on the heap)
sns   ; dup
ttt   ; retr - pull n onto the stack (this will be our n->1 counter, b)
nssn  ; label 'loop'
snt   ; swap - bring a to the top
ssstn ; push 1
tsss  ; add - increment a
sns   ; dup
tnst  ; putnum - output a as a number
snt   ; swap - bring b to the top
sns   ; dup
tnst  ; putnum - output b as a number
ssstn ; push 1
tsst  ; sub - decrement b
sns   ; dup
ntstn ; jez 'exit' if b is 0
nsnn  ; jmp 'loop'

Las primeras instrucciones son necesarias para configurar la pila correctamente, los comandos de entrada de Whitespace escriben en el montón, por lo que debemos copiar b (el valor de entrada) nuevamente en la pila. Comenzamos con a = 0 ya que es más corto declarar 0 en lugar de 1 (guarda un byte) y solo necesitamos reordenar la instrucción de incremento para hacer frente. Después de eso, simplemente repetimos e incrementamos a, salida a, salida b, decremento b, hasta que b llega a 0 (verificado después del decremento).

Ephphatha
fuente
esto podría ser mucho más divertido si eliminaras todo ese espacio en blanco: P
cat
4

Haskell, 65 48 47 bytes

1 byte guardado gracias a Laikoni:

f n=show=<<(\(l,r)->[l,r])=<<zip[1..][n,n-1..1]

6 bytes guardados gracias a nimi:

f n=show=<<(\(l,r)->[l,r])=<<zip[1..n][n,n-1..1]

Respuesta previa y explicación:

f n=concatMap show$concatMap(\(l,r)->[l,r])(zip[1..n][n,n-1..1])

Ya hay una mejor respuesta de Haskell aquí, pero soy nuevo tanto en Haskell como en el golf de código, así que también puedo publicarlo :)

Esta función comprime la lista [1..n] con su reverso, lo que resulta en una lista de tuplas.

[(1,n),(2,n-1),(3,n-2)..(n,1)]

Luego se usa concatMappara asignar una lambda a esta lista de tuplas que da como resultado una lista de listas ...

[[1,n],[2,n-1],[3,n-2]..[n,1]]

... y lo concatena.

[1,n,2,n-1,3,n-2..n,1]

Luego, un concatMapmapa final se asigna showa la lista y se concatena en una sola cadena.

f 26 "12622532442352262172081991810171116121513141413151216111710189198207216225234243252261"

Dan Ambrogio
fuente
2
La función infija =<<es la misma (dentro de la lista mónada) como concatMap: f n=show=<<(\(l,r)->[l,r])=<<zip[1..n][n,n-1..1].
nimi
1
1) Su solución actual es de solo 48 bytes. 2) Se puede dejar caer el nen [1..n]: Pruébelo en línea!
Laikoni
1) Errores Dang off-by-one ... 2) ¡Buena llamada!
Dan Ambrogio
3

Pyth, 7 bytes

jksC_BS

Pruébelo en línea: demostración

Explicación:

jksC_BSQ   implicit Q (=input number) at the end
      SQ   create the range [1, ..., Q]
    _B     bifurcate by inversion, this gives [[1, ..., Q], [Q, ..., 1]]
  sC       zip and flatten result
jk         join to a string
Jakube
fuente
3

Octava, 29 bytes

@(n)printf("%d",[1:n;n:-1:1])

Pruébalo en línea!

rahnema1
fuente
1
¡Mi implementación fue mucho, mucho más larga! ¡Agradable! =)
Stewie Griffin
3

Perl 6 , 20 bytes

{[~] 1..*Z~($_...1)}

Pruébalo

Con una entrada de 100000, esto lleva aproximadamente 10 segundos, incluida la compilación y la impresión de la salida.

Expandido:

{                # bare block lambda with implicit parameter 「$_」

  [~]            # reduce using concatenation operator 「&infix:«~»」
                 # (shorter than 「join '',」)

    1 .. *       # Range from 1 to infinity

    Z~           # zip using concatenation operator

    ( $_ ... 1 ) # deduced sequence starting at the input
                 # going down to 1
}

El Z~necesita el ~porque de lo contrario genera una lista de listas que se encadenarán con espacios.

No hay necesidad de limitar el Rango a partir de 1, porque se Zdetiene cuando se acaba cualquiera de las listas de entrada.
Esto ahorra dos bytes (se necesitaría un espacio después $_)

Brad Gilbert b2gills
fuente
3

Java 61 bytes

(int n)->{for(int i=0;i<n;System.out.print(i+1+""+(n-i++)));}
cheemcheem
fuente
2
Además, bienvenido a PPCG! :)
Stewie Griffin
Permitimos funciones anónimas, por lo que (int n)->{//for loop}debería funcionar aquí.
Nathan Merrill
¿Eso está mejor?
cheemcheem
2
¡Sí! Potencialmente, puede poner su System.out.print()en la última declaración del bucle for, pero se complica porque está usando idos veces (y necesita incrementarlo en la expresión).
Nathan Merrill
Puse la impresión dentro del bucle e incrementé i en el último lugar posible y luego lo verifiqué con los Casos de prueba para asegurarme de que funcionó, gracias @NathanMerrill
cheemcheem
3

Jalea , 5 bytes

RṚĖVV

Pruébalo en línea!

Cómo funciona

RṚĖVV  Main link. Argument: n

R      Range; yield [1, ..., n].
 Ṛ     Reverse; yield [n, ..., 1].
  Ė    Enumerate; yield [[1, n], ..., [n, 1]].
   V   Eval; convert each flat array to a string, interpret it as a Jelly program,
       and yield the output. This concatenates the integers in each pair, yielding
       a flat array of integers
    V  Repeat the previous step, concatenating the intgegers from before.
Dennis
fuente
3

Röda , 21 19 bytes

{seq 1,_<>seq _1,1}

Pruébalo en línea!

Esta es una función anónima que toma datos de la secuencia.

Explicación

{seq 1,_<>seq _1,1}               Anonymous function, takes integer n from the stream
        <>                        Interleave
 seq 1,_                            the range 1 .. n with
          seq _1,1                  the range n .. 1
Kritixi Lithos
fuente
2

Clojure, 61 bytes

#(let[a(range 1(+ 1 %))](apply str(interleave a(reverse a))))

Literalmente hace lo que se le pide. Creo que puede ser superado por una solución menos trivial.

Véalo en línea

acantilado
fuente
2

Aceto , 25 22 bytes

)&
pX`=
(pl0
id@z
r}Z)

Explicación:

Leemos un número entero y lo ponemos en dos pilas.

id
r}

En uno, llamamos a range_up ( Z), en el otro a range_down ( z), luego establecemos una marca de captura para poder regresar a este lugar más tarde:

  @z
  Z)

Luego verificamos si la pila actual está vacía y salimos si es así:

 X`=
  l0

De lo contrario, imprimimos desde ambas pilas y volvemos a la marca de captura:

)&
p
(p
L3viatán
fuente
2

R, 41 bytes

pryr::f(for(i in 1:x){cat(i);cat(x-i+1)})

pryr::f()crea una función que toma una entrada. Recorre 1:xe imprime cada elemento 1:xjunto con cada elemento de x:1. Imprime en STDOUT.

JAD
fuente
+1, buen uso depryr
shadowtalker
@ssdecontrol es su reemplazo básico de function(x):)
JAD
2

Brachylog , 10 9 bytes

⟦₁g↔ᶻczcc

Pruébalo en línea!

Explicación

⟦₁           [1, …, Input]
  g↔ᶻc       [[1, …, Input],[Input, …, 1]]
      z      Zip
       cc    Concatenate twice
Fatalizar
fuente
2

MATL, 13 11 9 bytes

2 bytes guardados gracias a @Luis

:tPv1eVXz

Pruébalo en MATL Online

Explicación

        % Implicitly grab input as a number, N
:       % Create an array from 1..N
tP      % Create a reversed copy
v       % Vertically concatenate the two
1e      % Reshape it into a row vector
V       % Convert to a string
Xz      % Remove whitespace and implicitly display
Suever
fuente
@LuisMendo Ah! Pensé que había una función que eliminaba los espacios en blanco pero no podía encontrarla. ¡Gracias!
Suever
2

PHP, 36 35 29 bytes

for(;$argn;)echo++$i,$argn--;

Salvado un byte gracias a Jörg Hülsermann.
Guardado seis bytes gracias a Christoph.

usuario63956
fuente
3
Uhm ... for(;$argn;)echo++$i,$argn--;?
Christoph
2

Scala, 43 bytes

No es el mejor, pero es mi primer código de golf.

n=>1.to(n).foldLeft("")((s,x)=>s+x+(n-x+1))
Fénix
fuente
2

V , 20 bytes

ywo1@"­ñykPjñkògJ

Pruébalo en línea!

Explique:

yw                    ' Copy the input number (for looping later)
  o1                 ' Insert a 1 under the input (on a newline)
     @"               ' [Copy register] number of times
       ­ñ      ñ       ' Do the thing inside of this loop
        ykP           ' Copy the current line and line above it, and paste above both
           j        ' decrement the current (top) number, and increment the one below
               k      ' Go to the top line
                ògJ   ' recursively join all of the lines
nmjcman101
fuente
2

Cubix , 17 bytes

....1I>sO)su.@?(O

Pruébalo en línea!

Cubicado:

    . .
    . .
1 I > s O ) s u
. @ ? ( O . . .
    . .
    . .

Empuja 1, lee en la entrada ( I), luego ingresa al bucle que intercambia la parte superior de la pila, lo genera, incrementa, intercambia, genera la parte superior de la pila, disminuye y se detiene si la parte superior de la pila es 0.

Giuseppe
fuente
2

MathGolf , 5 bytes

{îkï-

Pruébalo en línea!

Explicación:

{      Run a for loop over implicit input
 î     Push 1 based index of loop
  k    Push inputted number
   ï-  Subtract 0 based index of loop
       Implicitly output all this joined together
Jo King
fuente
1
He podido encontrar 13 programas de longitud 5, que producen el mismo resultado: ╒{ïí,, ╒{ïk,, ╒{íï-, ╒{kï-, ╒{┐í,, ╒{┐k,, ╒x{î\ , {îïí,, {îïk,, {îíï-, {îkï-, {î┐í,, {î┐k,. Sin embargo, no he podido encontrar ningún programa de longitud 4 o menos. No he hecho una búsqueda completa, pero es muy probable que 5 bytes sean óptimos para MathGolf.
maxb
2

Ratón-2002 , 32 30 bytes

-2 se movió condicional al inicio del ciclo en (z.^ ... )lugar de(... z.0>^)

?n:n.z:(z.^a.1+a:a.!z.!z.1-z:)

Pruébalo en línea!

Explicación:

?n:                                 ~ get input and store in n
   n.z:                             ~ copy n into z
       (z.^                         ~ stop if z equals 0
           a.1+a:                   ~ add 1 to a
                 a.!                ~ print a
                    z.!             ~ print z
                       z.1-z:)      ~ substract 1 from z
MooseOnTheRocks
fuente