Producto sobre gamas exclusivas e inclusivas

18

Inspirado en esta pregunta por @ CᴏɴᴏʀO'Bʀɪᴇɴ .

Tomado de la pregunta:

Su tarea es simple: dados dos enteros a y b, salida ∏ [a, b]; es decir, el producto del rango entre a y b. Puede tomar ayb en cualquier formato razonable, ya sean argumentos de una función, una entrada de lista, STDIN, etc. Puede imprimir en cualquier formato razonable, como un valor de retorno (para funciones) o STDOUT. a siempre será menor que b.

Tenga en cuenta que el final puede ser exclusivo o inclusivo de b. Yo no soy exigente. ^ _ ^

La diferencia para este desafío es que vamos a ser exigentes con el tipo de rango. Entrada es una cadena de la forma [a,b], (a,b], [a,b), o (a,b)donde un []es un límite incluido y ()es un límite exclusivo. Dados los límites explícitos, proporcione el producto del rango. Además, el rango de entrada siempre incluirá al menos 1 número, lo que significa que los rangos como (3,4)no son válidos y no necesitan ser probados.

Casos de prueba

[a,b) => result
[2,5) => 24
[5,10) => 15120
[-4,3) => 0
[0,3) => 0
[-4,0) => 24

[a,b] => result
[2,5] => 120
[5,10] => 151200
[-4,3] => 0
[0,3] => 0
[-4,-1] => 24

(a,b] => result
(2,5] => 60
(5,10] => 30240
(-4,3] => 0
(0,3] => 6
(-4,-1] => -6

(a,b) => result
(2,5) => 12
(5,10) => 3024
(-4,3) => 0
(0,3) => 2
(-4,0) => -6

Este es un código de golf , por lo que gana el programa más corto en bytes.

Tabla de clasificación

El Fragmento de pila al final de esta publicación genera el catálogo a partir de las respuestas a) como una lista de la solución más corta por idioma yb) como una tabla de clasificación general.

Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

## Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntuación, se puede mantener viejas cuentas en el título, golpeándolos a través. Por ejemplo:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

## Perl, 43 + 2 (-p flag) = 45 bytes

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

Mostrar fragmento de código

code-golf  math 
— Alexis Andersen
fuente

Respuestas:

7

LabVIEW, 38 primitivas de LabVIEW

"ligeramente" modificado, ahora establece los rangos escaneando () y [] y agregando el índice a los números.

primero

— Eumel
fuente
55
Al tener un idioma que requiere un gif sofisticado, inmediatamente has ganado ∞ rep. GG. +1
— Addison Crump
3

Python 2, 72 bytes

lambda s:reduce(int.__mul__,range(*eval(s[1:-1]+'+'+`']'in s`))[s<'[':])

Para extraer los números que evaluamos s[1:-1], la cadena de entrada con los extremos eliminados, lo que da una tupla. La idea es obtener rangeesta tupla y tomar el producto.

lambda s:reduce(int.__mul__,range(*eval(s[1:-1]))

La falsificación pasa para ajustar los puntos finales. El punto final superior es fácil, solo corte el primer elemento si la entrada comienza con (, hecho como [s<'[':].

El otro punto final es más complicado. Python no tiene una forma limpia de eliminar condicionalmente el último elemento de una lista porque l[:0]elimina todo. Entonces, hacemos algo raro. Modificamos la cadena de tupla antes de que se evalúe para agregarla "+True"o "+False"dependiendo de si s termina en ]o ). El resultado es que algo así se 3,7convierte en 3,7+Falsecuál es 3,7o 3,7+Truecuál es 3,8.

Alterno, más bonito 72:

lambda s:eval("reduce(int.__mul__,range((s<'[')+%s+(']'in s)))"%s[1:-1])
— xnor
fuente
3

Minecraft 15w35a +, tamaño total del programa 638 (ver más abajo)

Igual que mi respuesta aquí , pero modificado. Dado que Minecraft no tiene entrada de cadena, me tomé la libertad de mantener la entrada del marcador. Si eso es un problema, considere esta respuesta no competitiva.

ingrese la descripción de la imagen aquí

Esto se calcula PI a,bcon inclusivo / exclusivo especificado por las dos palancas. ingrese la descripción de la imagen aquíLa entrada se proporciona mediante el uso de estos dos comandos: /scoreboard players set A A {num}y /scoreboard players set B A {num}. Recuerde usar /scoreboard objectives add A dummyantes de la entrada.

Calificado usando: {program size} + ( 2 * {input command} ) + {scoreboard command} = 538 + ( 2 * 33 ) + 34 = 638.

Este código corresponde al siguiente psuedocódigo:

R = 1
T = A
loop:
  R *= A
  A += 1
  if A == B:
    if A.exclusive:
      R /= T
    if B.exclusive:
      R /= B
    print R
    end program

Descarga el mundo aquí .

— GamrCorps
fuente
2

Pyth, 20 bytes

*FPW}\)ztW}\(z}FvtPz

Pruébelo en línea: Demostración o conjunto de pruebas

Explicación:

*FPW}\)ztW}\(z}FvtPz   implicit: z = input string
                 tPz   remove the first and last character of z
                v      evaluate, returns a tuple of numbers
              }F       inclusive range
        tW             remove the first number, if
          }\(z            "(" in z
  PW                   remove the last number, if
    }\)z                  ")" in z
*F                     compute the product of the remaining numbers
— Jakube
fuente
2

Ruby, 79 77 bytes

->s{a,b=s.scan /\-?\d+/;(a.to_i+(s[?[]?0:1)..b.to_i-(s[?]]?0:1)).reduce 1,:*}

79 bytes

->s{a,b=s.scan(/\-?\d+/).map &:to_i;((s[?[]?a:a+1)..(s[?]]?b:b-1)).reduce 1,:*}

Sin golf:

-> s {
  a,b=s.scan /\-?\d+/    # Extracts integers from the input string, s
  (
    a.to_i+(s[?[]?0:1).. # Increase start of the range by 1 if s contains `(`
    b.to_i-(s[?]]?0:1)   # Decrease end of the range by 1 if s contains `)`
  ).reduce 1,:*
}

Uso:

->s{a,b=s.scan /\-?\d+/;(a.to_i+(s[?[]?0:1)..b.to_i-(s[?]]?0:1)).reduce 1,:*}["(2,5]"]
=> 60
— Vasu Adari
fuente
2

En serio, 31 bytes

,#d@p@',@s`εj≈`Mi(@)']=+)'(=+xπ

Toma la entrada como una cadena (entre comillas dobles)

Pruébelo en línea (la entrada debe ingresarse manualmente)

Explicación:

,#d@p@                             get input, take first and last character off and push them individually
      ',@s`εj≈`Mi                  split on commas, map: join on empty, cast to int; explode list
                 (@)']=+)'(=+      increment start and end if braces are ( and ] respectively (since range does [a,b))
                             xπ    make range, push product
— Mego
fuente
1

Pitón 3, 104

y,r=input().split(',')
t=int(y[1:])+(y[0]<')')
for x in range(t+1,int(r[:-1])+(r[-1]>'[')):t*=x
print(t)

Toma información de stdin.

— Morgan Thrapp
fuente
en realidad publicamos nuestras respuestas en el mismo segundo Oo
— Eumel
@Eumel Eso debería ser una insignia.
— Morgan Thrapp
realmente publicaré eso en Meta ahora mismo ^^
— Eumel
@Eumel: En realidad publicaste el tuyo 1 segundo antes de Morgan Thrapp's
— ev3commander
¿Oh enserio? se mostró respondida hace n segundos en ambas respuestas
— Eumel
1

MATLAB, 86 70 bytes

s=sscanf(input(''),'%c%d,%d%c');a=s<42;disp(prod(a(1)+s(2):s(3)-a(4)))

Esto también funciona con Octave . Puedes probar en línea aquí . He agregado el código como un script a ese espacio de trabajo, por lo que puede ingresar productRangeen el indicador y luego ingresar su entrada, por ejemplo '(2,5]'.

Entonces, el código primero escanea la entrada para extraer los corchetes y los números juntos:

s=sscanf(input(''),'%c%d,%d%c');

Esto devuelve una matriz que está hecha de [bracket, number, number, bracket].

La matriz se compara con 42, en realidad cualquier número entre 42 y 90 inclusive lo hará. Esto determina qué tipo de corchete era, dando un 1 si es un corchete exclusivo y un 0 si es un corchete inclusivo.

a=s<42;

Finalmente, mostramos el producto del rango requerido:

disp(prod(a(1)+s(2):s(3)-a(4)))

El producto es de números que comienzan con el primer número s(2)más el primer tipo de paréntesis a(1)(que es un 1 si es un paréntesis exclusivo), que van hasta e incluyen el segundo número s(3)menos el segundo tipo de paréntesis a(4). Esto proporciona el rango inclusivo / exclusivo correcto.

— Tom Carpenter
fuente
1

Julia, 75 bytes

s->prod((x=map(parse,split(s[2:end-1],",")))[1]+(s[1]<41):x[2]-(s[end]<42))

Esta es una función anónima que acepta una cadena y devuelve un entero. Para llamarlo, dale un nombre, por ejemplo f=s->....

Sin golf:

function f(s::AbstractString)
    # Extract the numbers in the input
    x = map(parse, split(s[2:end-1], ","))

    # Construct a range, incrementing or decrementing the endpoints
    # based on the ASCII value of the surrounding bracket
    r = x[1]+(s[1] == 40):x[2]-(s[end] == 41)

    # Return the product over the range
    return prod(r)
end
— Alex A.
fuente
1

Mathematica, 128 bytes

1##&@@Range[(t=ToExpression)[""<>Rest@#]+Boole[#[[1]]=="("],t[""<>Most@#2]-Boole[Last@#2==")"]]&@@Characters/@#~StringSplit~","&

Esto es demasiado largo ... Actualmente estoy pensando en una solución StringReplace+ RegularExpression.

— LegionMammal978
fuente
0

PowerShell, 146104 bytes

param($i)$a,$b=$i.trim("[]()")-split',';($a,(1+$a))[$i[0]-eq'(']..($b,(+$b-1))[$i[-1]-eq')']-join'*'|iex

Golfó 42 bytes cambiando cómo se extraen los números de la entrada. ¡Cortejar!

param($i)                          # Takes input string as $i
$a,$b=$i.trim("[]()")-split','     # Trims the []() off $i, splits on comma,
                                   # stores the left in $a and the right in $b

($a,(1+$a))[$i[0]-eq'(']..($b,(+$b-1))[$i[-1]-eq')']-join'*'|iex
# Index into a dynamic array of either $a or $a+1 depending upon if the first
# character of our input string is a ( or not
# .. ranges that together with
# The same thing applied to $b, depending if the last character is ) or not
# Then that's joined with asterisks before
# Being executed (i.e., eval'd)
— AdmBorkBork
fuente
0

Perl 6 , 60 bytes

{s/\((\-?\d+)/[$0^/;s/(\-?\d+)\)/^$0]/;s/\,/../;[*] EVAL $_}

Hay un poco de falta de coincidencia porque la forma en que escribiría el (2,5]ejemplo en Perl 6 sería 2^..5( [2^..5]también funciona).
Entonces tengo que intercambiar (2con [2^, y ,con .., luego tengo que EVALhacerlo en un Rango.

uso:

# give it a name
my &code = {...}

# the `$ =` is so that it gets a scalar instead of a constant

say code $ = '(2,5)'; # 12
say code $ = '[2,5)'; # 24
say code $ = '(2,5]'; # 60
say code $ = '[2,5]'; # 120

say code $ = '(-4,0)' # -6
say code $ = '[-4,0)' # 24
say code $ = '(-4,0]' # 0
say code $ = '[-4,0]' # 0

say code $ = '(-4,-1)' # 6
say code $ = '[-4,-1)' # -24
say code $ = '(-4,-1]' # -6
say code $ = '[-4,-1]' # 24

# this is perfectly cromulent,
# as it returns the identity of `*`
say code $ = '(3,4)'; # 1
— Brad Gilbert b2gills
fuente
0

CJam, 34 bytes

r)\(@+"[()]"2/\.#\',/:i.+~1$-,f+:*

Pruébalo en línea

Explicación:

r       Read input.
)       Split off last character.
\       Swap rest of input to top.
(       Split off first character.
@       Rotate last character to top.
+       Concatenate first and last character, which are the two braces.
"[()]"  Push string with all possible braces.
2/      Split it into start and end braces.
\       Swap braces from input to top.
.#      Apply find operator to vector elements, getting the position of each brace
        from input in corresponding list of possible braces. The lists of braces
        are ordered so that the position of each can be used as an offset for the
        start/end value of the interval.
\       Swap remaining input, which is a string with two numbers separated by
        a comma, to top.
',/     Split it at comma.
:i      Convert the two values from string to integer.
.+      Element-wise addition to add the offsets based on the brace types.
~       Unwrap the final start/end values for the interval.
1$      Copy start value to top.
-       Subtract it from end value.
,       Build 0-based list of values with correct length.
f+      Add the start value to all values.
:*      Reduce with multiplication.
— Reto Koradi
fuente
0

JavaScript (ES6), 90 bytes

s=>eval(`for(n=s.match(/-*\\d+/g),i=n[0],c=s[0]<"["||i;++i<+n[1]+(s.slice(-1)>")");)c*=i`)

Explicación

s=>
  eval(`                    // use eval to allow for loop without return or {}
    for(
      n=s.match(/-*\\d+/g), // n = array of input numbers [ a, b ]
      i=n[0],               // i = current number to multiply the result by
      c=s[0]<"["||i;        // c = result, initialise to a if inclusive else 1
      ++i<+n[1]             // iterate from a to b
        +(s.slice(-1)>")"); // if the end is inclusive, increment 1 more time
    )
      c*=i                  // multiply result
  `)                        // implicit: return c

Prueba

Mostrar fragmento de código

— usuario81655
fuente
0

R, 102 104 bytes

f=function(s){x=scan(t=gsub('\\(|\\[|,|\\)|\\]',' ',s))+c(grepl('^\\(',s),-(grepl('\\)$',s)));prod(x[1]:x[2])}

Sin golf

f=function(s){
    # remove delimiting punctuation from input string, parse and return an atomic vector
    x=scan(t=gsub('\\(|\\[|,|\\)|\\]',' ',s)) +
    # add /subtract from the range dependent on the `[)` pre/suf-fixes
    c(grepl('^\\(',s),-(grepl('\\)$',s)))
    # get the product of the appropriate range of numbers
    prod(x[1]:x[2])
}

editar para permitir números negativos [a expensas de 2 caracteres más

— mnel
fuente
Idioma?
— ThisSuitIsBlackNot
@ThisSuitIsBlackNot - R(y corregido en respuesta)
— mnel
0

JavaScript (ES6), 79

Como un método anónimo

r=>eval("[a,b,e]=r.match(/-?\\d+|.$/g);c=a-=-(r<'@');for(b-=e<'@';a++<b;)c*=a")

Fragmento de prueba

F=r=>eval("[a,b,e]=r.match(/-?\\d+|.$/g);c=a-=-(r<'@');for(b-=e<'@';a++<b;)c*=a")

// TEST
console.log=x=>O.innerHTML+=x+'\n'

;[
 ['[2,5)',24],['[5,10)',15120],['[-4,3)',0],['[0,3)',0],['[-4,0)',24],
 ['[2,5]',120],['[5,10]',151200],['[-4,3]',0],['[0,3]',0],['[-4,-1]',24],
 ['(2,5]',60],['(5,10]',30240],['(-4,3]',0],['(0,3]',6],['(-4,-1]',-6],
 ['(2,5)',12],['(5,10)',3024],['(-4,3)',0],['(0,3)',2],['(-4,0)',-6]
].forEach(t=>{
  r=F(t[0]),k=t[1],console.log(t[0]+' -> '+r+' (check '+k+ (k==r?' ok)':' fail)'))
})
<pre id=O></pre>
Expandir fragmento

— edc65
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.