N números más cercanos a cero se mantienen equilibrados


10

Objetivo : dado un entero positivo n:

  • Si nes impar, muestre la lista de nnúmeros más cercanos 0en orden creciente
  • Si nes par, genera un valor de Falsey.

Casos de prueba :

5 -> [-2,-1,0,1,2]
4 -> false (or any Falsey value)
1 -> [0]

Implementación de referencia

function update(){
  var num = +document.getElementById("yield").value;
  if(num){
    var out = document.getElementById("output");
    if(num % 2 == 1){
      // base is balanced
      var baseArr = [];
      for(var i=0;i<num;i++){
        baseArr.push(i-Math.floor(num/2));
      }
      out.innerHTML = baseArr.join(" ");
    } else {
      out.innerHTML = "false";
    }
  } else {
    out.innerHTML = "<i>enter input</i>";
  }
}

setInterval(update,1);
* {
  font-family: "Constantia", "Consolas", monospace;
}

[type="number"] {
  width: 10px;
  width: 2em;
}

#output {
  font-family: "Consolas", monospace;
}
Input: <input type="number" id="yield" value="3"> is <span id="output"><i>enter input</i></span>


¿Puede la salida ser un objeto de rango en lugar de una lista?
Brad Gilbert b2gills

@ BradGilbertb2gills Lo sentimos, un objeto de rango es una salida no válida.
Conor O'Brien

La lista vacía no siempre es falsey.
SuperJedi224

@ SuperJedi224 ¿En qué contextos?
Conor O'Brien

Hay idiomas (IE Javascript) en los que la lista vacía se considera un valor verdadero.
SuperJedi224

Respuestas:


4

Pyth, 10 bytes

*-R/Q2Q%Q2

Pruébalo en línea.

Cómo funciona

            (implicit) Store the input in Q.
   /Q2      Calculate Q/2 (integer division).
 -R   Q     Subtract that value (-R) from each element in [0, ..., Q-1] (Q).
*      %Q2  Repeat the resulting array Q%2 times.

5

APL, 16 15 13 bytes

¡Gracias a @Dennis por -2 bytes!

⌊(⍳⊢×2|⊢)-÷∘2

Este es un tren monádico que proporciona una matriz vacía para una entrada uniforme. A continuación se muestra el diagrama:

┌────┴─────┐   
⌊ ┌────────┼─┐ 
┌─┴─┐      - ∘ 
⍳ ┌─┼───┐   ┌┴┐
  ⊢ × ┌─┼─┐ ÷ 2
      2 | ⊢    

Primero, ⊢×2|⊢le da a la entrada veces su mod 2; es decir, las probabilidades se darán a sí mismas, y las pares darán 0. Usamos para crear una lista de números de 1 a eso ( ⍳0da la matriz vacía), y luego restamos la mitad de la entrada y el piso.


5

Mathematica, 32 30 24 bytes

OddQ@#&&Range@#-(#+1)/2&

Truco de golf de código: el último argumento para Andno tiene que ser un booleano.


Puede guardar un byte utilizando los corchetes Unicode para Floor.
Martin Ender

Además, Range[-a,a=...]parece funcionar, guardando otro byte.
Martin Ender

OddQ@#&&Range@#-(#+1)/2&
ngenisis

4

PowerShell, 50 52 bytes

param($a)$b=$a/2-.5;(0,((0-$b)..$b-join' '))[($a%2)]

Oof Respuesta bastante detallada. Toma entrada $a, luego establece una nueva variable $bcomo el "piso" de $a/2. Genera un nuevo rango de números desde (0-$b)hasta $b, luego joins el rango con espacios, y lo tiene como el segundo elemento de una matriz de dos elementos (el primer elemento es 0). Luego se utiliza $a%2para indexar en esa matriz para la salida.

Versión alternativa que usa un flujo if / else más "tradicional", a 54 bytes:

param($a)$b=$a/2-.5;if($a%2){(0-$b)..$b-join' ';exit}0

Editar: necesario para agregar algo de lógica para generar un valor falsey si la entrada es uniforme


Ahorre 3 bytes cambiando (0-$b)a solo -$b. Además, simplemente multiplicando por *0generará una cadena nula (se evalúa como falsa en powershell). (ver: codegolf.stackexchange.com/a/63005/45925 )
Jonathan Leech-Pepin

4

Haskell, 37 36 31 bytes

g n=take(n*mod n 2)[-div n 2..]

Desequilibrado se indica mediante la lista vacía. Ejemplo de uso: g 7-> [-3,-2,-1,0,1,2,3].

@xnor encontró 5 bytes. ¡Gracias!


¿No hay forma de hacer que el caso de la lista vacía sea una condición? Hacer g n=[x|x<-[-div n 2..(n+1)/2],odd n]es igual de largo.
xnor

34:g n=[1|odd n]>>[-div n 2..div n 2]
xnor

Deberías editarlo, es un pequeño cambio.
xnor

g n=[1|odd n]>>take n[-div n 2..]También ahorra un char.
xnor

1
@xnor: lo estás jugando más rápido de lo que puedo editar mis publicaciones.
nimi

4

JavaScript (ES6), 44 43 42 41 bytes

tachado 44 sigue siendo regular 44; (

n=>[...Array(n&1&&n--)].map((x,i)=>i-n/2)

Para entradas impares, devuelve una matriz entera de longitud x, centrada en 0; para incluso, devuelve 0. Creo que esto es lo más corto posible. (¡Ahorré un par de bytes gracias a @ edc65 y @ ן nɟuɐɯɹɐ ן oɯ!)

Alternativa ES6: (42 bytes, gracias a @intrepidcoder)

x=>x%2&&[for(y of Array(x--).keys())y-x/2]

Sugerencias bienvenidas!


El uso x%2&&[for(y of...]guarda un byte.
intrepidcoder

ES6, 43, n=>Array(n&1&&n--).fill().map((x,i)=>i-n/2)si está permitido devolver una matriz vacía
edc65

@intrepidcoder ¡Gracias! He cambiado esto
ETHproductions

@ edc65 ¡Gracias también! He agregado esto a la respuesta.
ETHproductions

x=>x%2&&[for(y of Array(x--).keys())y-x/2]es 42.
intrepidcoder

3

Minkolang 0.10 , 18 bytes

nd2%?.d2:~r[dN1+].

Explicación

n          Take input as integer (k)
d2%?.      Duplicate k and stop if it's even
d2:~       Duplicate k, then divide by 2 and negate to get first number
r          Put k on top
[    ].    Loop k times and then stop
 dN1+      Duplicate, output as integer, and increment

3

J, 12 bytes

i:@%~2&!*2&|

Este es un verbo monádico que devuelve 0(falso) para números pares. Pruébelo en línea con J.js .

Prueba de funcionamiento

   (i:@%~2&!*2&|) 3
_1 0 1
   (i:@%~2&!*2&|) 2
0

Cómo funciona

              Right argument: y
         2&|  Take y modulo 2.
     2&!      Calculate y C 2 = y(y-1)/2.
        *     Multiply the results.
   %~         Divide the product by y.
              This yields (y-1)*(y%2)/2 = (y-1)/2 (y even) | 0 (y odd).
  @           Take the result and...
i:              apply the bilateral index generator z -> (-z ... z).

3

DUP , 31 bytes

[a:a;2/b:[b;_[$b;<][$1+]#][0]?]

Try it here.

Lambda anónima. Uso:

5[a:a;2/b:[b;_[$b;<][$1+]#][0]?]!

Explicación

[                             ] {lambda}
 a:                             {store input to a}
   a;2/                         {divmod a by 2}
       b:                       {store quotient to b, top of stack is now remainder}
         [               ][ ]?  {conditional}
          b;_                   {if remainder is 1, get b and negate it}
             [    ][   ]#         {while loop}
              $b;<                {while top of stack is less than b}
                    $1+           {duplicate and increment}
                           0    {otherwise, leave falsy value}

2

Python 2, 34 32 Bytes

En este momento no estoy seguro si puedo generar lo que quiera si no está equilibrado, por lo que actualmente esto solo devuelve una lista vacía en el caso de una base desequilibrada. Es una función lambda anónima, así que dale un nombre para usarla.

lambda k:k%2*range(-k/2+1,-~k/2)

Si lo haces k%2*, puedes evitar a los padres.
xnor

2

CJam, 13 12 bytes

{_2md@,@f-*}

Esta es una función anónima que saca un número entero de la pila y empuja una matriz de dígitos (base impar) o una matriz vacía (base par) a cambio. Pruébelo en línea en el intérprete de CJam .

Cómo funciona

_          e# Copy the input (N).
 2md       e# Push N/2 and N%2.
    @      e# Rotate N on top of the stack.
     ,     e# Push [0 ... N-1].
      @    e# Rotate N/2 on top of the stack.
       f-  e# Subtract N/2 from each element of [0 ... N-1].
         * e# Repeat the resulting array N%2 times.


2

Vitsy, 27 25 bytes

Mañana jugaré golf, pero realmente debería irme a la cama ahora.

D2M) [& 1] D1-i *} \ [D2 / NaO2 +]
D Duplicar la entrada.
 2M) [& 1] Si la entrada es par (entrada% 2 = 0) genera una nueva pila
                              y presiona 1 hacia él.
        D Duplique el valor superior; si no fuera uniforme, esta será la entrada. De lo contrario, es uno.
         1- Resta uno (para equilibrar alrededor de cero)
           i * Invertir aditivamente
             } Cambiar sobre un elemento en la pila: esto asegura que
                              Tenemos la entrada o una en la parte superior.
              \ [] Repita los tiempos de entrada.
                D2 / N Duplicar el elemento superior e imprimirlo.
                    aO Newline (estoy bastante seguro de que esta es una separación válida)
                      2+ Agregue uno al elemento superior de la pila.

"Var global final" que suena intenso
Conor O'Brien

3
Que es intensa.
Addison Crump

La intensidad de
Addison Crump

2

TeaScript , 16 bytes 18

x%2Þr(xØ)ßl-x/2)

Bastante simple. Los caracteres especiales son en realidad "abreviaturas" para secuencias de código más largas.

Todavía no he hecho enlaces permanentes, así que tendrás que copiar y pegar en el intérprete

Explicación

x%2 &&    // If x is NOT even return falsy, else...
r(x--)    // Range 0-input. Subtracts one from input
m(#       // Loop through range
  l-      // Current item in loop, minus...
    x/2   // input - 1, divided by two
)

Esta respuesta no es competitiva.


Debería implementar estas abreviaturas de caracteres especiales en Japt. :) Por cierto, ¿estás seguro de que Ω es 1 byte?
ETHproductions

@ETHproductions Aww :( olvidé comprobar eso antes de implementar eso. Lo arreglaré en el próximo commit
Downgoat el

1
@ Vɪʜᴀɴ Nah, es un buen desafío / peculiaridad que mantiene las cosas interesantes. Además, los caracteres no imprimibles se ven geniales.
Mama Fun Roll

44
@ ן nɟuɐɯɹɐ ן oɯ Siempre y cuando realmente puedas verlos. En mi teléfono, ni siquiera se ve el nombre de su idioma . : P
Dennis

2
@Dennis Se suma al misterioso aura del lenguaje ...
Mama Fun Roll

2

F #, 38 bytes

El resultado falsey es una lista vacía.

let O n=if n%2<1 then[]else[-n/2..n/2]


2

Japt, 21 19 bytes

Japt es una versión abreviada de Ja vaScri pt .

U%2&&(X=-U/2+K o1-X

Para entradas impares, devuelve una matriz entera de longitud x, centrada en 0; para par, devuelve 0. Traducción aproximada de JS:

output(U%2&&(X=-U/2+.5).range(1-X));

donde x.range(y)crea una lista de enteros de xa y. ¡Pruébalo en línea!


En Japt moderno, esto es solo 11 bytes:

u ©Uo-U/2-½

Pruébalo en línea!


55
A quien haya rechazado esta respuesta, ¿puede explicar por qué? Me gustaría saber dónde me equivoqué para poder solucionarlo. Gracias. :-)
ETHproductions

3
¿Quizás no les gusta el idioma? (Me encanta el idioma, aunque puedo ver cómo otros podrían no hacerlo)
Conor O'Brien

1

R, 30 bytes

function(n)(x=(1-n)/2*n%%2):-x

A grandes rasgos, x:-xdevuelve los números enteros de xa -x, donde hice xa (1-n)/2. También utilizo el factor módulo 2 n%%2en la definición de xforzar xa cero cuando nes par, en cuyo caso, 0:0retornos 0(falsey).


1

Perl, 36 bytes

Tengo la sensación de que esto se puede acortar:

$,=$";$n=<>;print$n%2?-$n/2..$n/2:0;

El rango trata los flotantes como enteros, por lo que, por ejemplo, 5/2 = 2.5 se convierte silenciosamente en 2.

(Si el formato no importa, elimínelo $,=$";por un total de 30 bytes).


1

Powershell, 49 bytes

param($a)$b=$a/2-.5;"[$(-$b..$b-join",")]"*($a%2)

Números pares evaluados $falseya que proporcionan una salida de línea vacía.

("[$(-$b..$b-join",")]"*($a%2))-eq $True ===> False

Los números impares generan la cadena de referencia exacta. Puede guardar 4 bytes más (ahora 45) quitando el []de la cadena de salida.

PS> .\balanced.ps1 4


PS> .\balanced.ps1 5
[-2,-1,0,1,2]

PS> .\balanced.ps1 0


PS> .\balanced.ps1 1
[0]

PS> 

Powershell, 36 bytes

param($a)$b=$a/2-.5;(-$b..$b)*($a%2)

Esto tiene el mismo resultado falsey pero genera la lista de números separados por nuevas líneas:

PS> .\balanced-newline.ps1 4

PS> .\balanced-newline.ps1 1
0

PS> .\balanced-newline.ps1 5
-2
-1
0
1
2

PS>

1

Perl 6, 25 bytes

La expresión lambda más corta que se me ocurrió que genera una lista en lugar de un rango es:

{$_%2&&|((1-$_)/2..$_/2)} # 25

Pruebas:

for 0..10 -> $a {
  if {$_%2&&|((1-$_)/2..$_/2)}($a) -> $b {
    say "$a.fmt('%5s')  $b"
  } else {
    say "$a.fmt('%5s')  False"
  }
}
    0  False
    1  0
    2  False
    3  -1 0 1
    4  False
    5  -2 -1 0 1 2
    6  False
    7  -3 -2 -1 0 1 2 3
    8  False
    9  -4 -3 -2 -1 0 1 2 3 4
   10  False

Esto aprovecha el hecho de que Perl 6 trata el número 0como un valor falso. Si la salida tuvo que ser exactamente Falsepodría reemplazar $_%2con $_!%%2.


1

05AB1E , 8 bytes (no competitivos)

El lenguaje es posterior al desafío y, por lo tanto, no es competitivo. Código:

È#¹;D(ŸR

Pruébalo en línea!

Explicación:

È#        # If input % 2 == 0, end the program
  ¹       # Push the first input from the register
   ;      # Halve, push input / 2 rounded down
    D     # Duplicate top of the stack
     (    # Negate
      Ÿ   # Inclusive range, pushes [a .. b]
       R  # Reverse the array

Utiliza la codificación CP-1252 .


0

PHP, 50 bytes

<?=($n=$argv[1])&1?join(_,range(-$k=$n/2|0,$k)):0;

programa, toma la entrada de STDIN, imprime la _lista delimitada o 0.

o

function f($n){return$n&1?range(-$k=$n/2|0,$k):0;}

La función toma argumento, devuelve matriz o 0.


0

Java, 145 bytes

public class c{static void c(int n){for(int i=n/2*-1;i<=n/2;i++){if(n%2==0){System.out.print("false");break;}System.out.print(i);}}}

Explicación: Lo siento, sé que esto es realmente largo. No vi una respuesta para Java, así que decidí poner una. Avíseme si necesito escribir la función principal (no estoy seguro de si esa es la política o no). Básicamente divide el número por dos y lo multiplica por -1 para el límite inferior y para el límite superior solo usa el número dividido por dos. Soy un poco nuevo en esta página, así que si no formateé nada correctamente, avíseme. Además, sé que las respuestas se pueden acortar con las funciones lambda, pero no sé cómo usarlas y no estoy seguro de si Java las admite.

Aquí hay una versión más legible que es menos golf:

public class StackOverflow {
static void c(int n){
    for (int i = n/2*-1; i<=n/2; i++){
        if(n%2==0){
            System.out.print("false");
            break;
        }
        System.out.print(" " + i);
    }
}
}

La regla normal es que necesita escribir un programa o función. En Java, una función casi siempre será más corta (especialmente porque le permite generar a través de return- el valor de retorno es una forma legítima de salida - en lugar de necesitar usar System.out, aunque en este caso para returntrabajar necesitaría almacenar parcialmente listas construidas en una cadena). Java reciente admite lambdas, y normalmente son más cortas que una definición de función "regular". (Además, ¿por qué el espacio en blanco principal?)

@ ais523 El espacio en blanco líder es solo mi propio hábito personal y no lo incluí en el conteo de bytes, creo que debería deshacerme de él. ¡Gracias por la ayuda!
Henry

0

Rubí, 25 bytes.

->n{n%2>0&&[*(-n/=2)..n]}

0

Rubí, 27 bytes

->n{[*0-n/2..n/2]if n.odd?}

Crea una función lambda anónima que devolverá la matriz de nnúmeros más cercana a 0 si n es impar y, de lo contrario, devuelve nil (un valor falsey en rubí).

Ruby redondea su división entera hacia -infinito, pero 0-n/2es más corta que -n/2+1(ya que el signo menos está ahí de todos modos), y debido a que n ahora se considera positivo, el redondeo funciona a mi favor.

Versión anterior (28 bytes)

->n{[*-n/2+1..n/2]if n.odd?}
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.