Produit sur des gammes exclusives et inclusives

18

Inspiré de cette question par @ CᴏɴᴏʀO'Bʀɪᴇɴ .

Tiré de la question:

Votre tâche est simple: étant donné deux entiers a et b, la sortie ∏ [a, b]; c'est-à-dire le produit de la plage entre a et b. Vous pouvez prendre a et b dans n'importe quel format raisonnable, que ce soit des arguments à une fonction, une entrée de liste, STDIN, et cetera. Vous pouvez sortir dans n'importe quel format raisonnable, comme une valeur de retour (pour les fonctions) ou STDOUT. a sera toujours inférieur à b.

Notez que la fin peut être exclusive ou inclusive de b. Je ne suis pas pointilleux. ^ _ ^

La différence pour ce défi est que nous allons être pointilleux sur le type de gamme. Entrée est une chaîne de la forme [a,b], (a,b], [a,b), ou (a,b)où []est une limite inclusive et ()est une limite exclusive. Compte tenu des limites explicites, fournir le produit de la gamme. De plus, la plage d'entrée comprendra toujours au moins 1 chiffre, ce qui signifie que les plages comme ne (3,4)sont pas valides et n'ont pas besoin d'être testées.

Cas de test

[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

Il s'agit d'un code-golf , donc le programme le plus court en octets l'emporte.

Classement

L'extrait de pile au bas de cet article génère le catalogue à partir des réponses a) en tant que liste des solutions les plus courtes par langue et b) en tant que classement général.

Pour vous assurer que votre réponse s'affiche, veuillez commencer votre réponse avec un titre, en utilisant le modèle Markdown suivant:

## Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les barrant. Par exemple:

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

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou que vous souhaitez répertorier les pénalités de drapeau d'interprète séparément), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de code:

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

Afficher l'extrait de code

code-golf  math 
— Alexis Andersen
source

Réponses:

7

LabVIEW, 38 primitives LabVIEW

"légèrement" modifié, définit maintenant les plages en balayant () et [] et en ajoutant l'index aux nombres.

first

— Eumel
source
5
En ayant une langue qui nécessite un gif fantaisie, vous avez immédiatement gagné ∞ rep. GG. +1
— Addison Crump
3

Python 2, 72 octets

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

Pour extraire les nombres que nous évaluons s[1:-1], la chaîne d'entrée avec les extrémités supprimées, ce qui donne un tuple. L'idée est de récupérer rangece tuple et de prendre le produit.

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

Le fudging se produit pour ajuster les points de terminaison. Le point final supérieur est facile, il suffit de couper le premier élément si l'entrée commence par (, faites comme [s<'[':].

L'autre point final est plus délicat. Python n'a pas de méthode propre pour supprimer conditionnellement le dernier élément d'une liste carl[:0] supprime le tout. Donc, nous faisons quelque chose de bizarre. Nous modifions la chaîne de tuple avant qu'elle ne soit évaluée pour clouer sur la chaîne "+True"ou "+False"selon que s se termine par ]ou ). Le résultat est que quelque chose comme 3,7devient ce 3,7+Falsequi est 3,7ou 3,7+Truece qui est 3,8.

Alterné, plus joli 72:

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

Minecraft 15w35a +, taille du programme 638 au total (voir ci-dessous)

Identique à ma réponse ici , mais modifiée. Comme Minecraft n'a pas d'entrée de chaîne, j'ai pris la liberté de conserver l'entrée du tableau de bord. Si c'est un problème, considérez cette réponse comme non compétitive.

entrez la description de l'image ici

Celui-ci est calculé PI a,bavec inclusif / exclusif spécifié par les deux leviers. entrez la description de l'image iciL'entrée est donnée en utilisant ces deux commandes: /scoreboard players set A A {num}et /scoreboard players set B A {num}. N'oubliez pas d'utiliser /scoreboard objectives add A dummyavant la saisie.

A marqué en utilisant: {program size} + ( 2 * {input command} ) + {scoreboard command} = 538 + ( 2 * 33 ) + 34 = 638.

Ce code correspond au pseudo-code suivant:

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

Téléchargez le monde ici .

— GamrCorps
source
2

Pyth, 20 octets

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

Essayez-le en ligne: démonstration ou suite de tests

Explication:

*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
source
2

Rubis, 79 77 octets

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

79 octets

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

Non 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,:*
}

Usage:

->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
source
2

Sérieusement, 31 octets

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

Prend l'entrée sous forme de chaîne (entourée de guillemets doubles)

Essayez-le en ligne (l'entrée doit être entrée manuellement)

Explication:

,#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
source
1

Python 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)

Prend l'entrée de stdin.

— Morgan Thrapp
source
nous avons en fait posté nos réponses dans la même seconde Oo
— Eumel
@Eumel Cela devrait être un badge.
— Morgan Thrapp
je ne poste pas ça sur Meta en ce moment ^^
— Eumel
@Eumel: En fait, vous avez publié le vôtre 1 seconde avant Morgan Thrapp
— ev3commander
Oh vraiment? il a répondu il y a n secondes sur les deux réponses
— Eumel
1

MATLAB, 86 70 octets

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

Cela fonctionne également avec Octave . Vous pouvez essayer en ligne ici . J'ai ajouté le code en tant que script à cet espace de travail, vous pouvez donc simplement entrer productRangeà l'invite, puis entrez votre entrée, par exemple '(2,5]'.

Ainsi, le code analyse d'abord l'entrée pour extraire les crochets et les nombres ensemble:

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

Cela renvoie un tableau qui est fait de [bracket, number, number, bracket].

Le tableau est comparé à 42, en fait, n'importe quel nombre entre 42 et 90 inclus fera l'affaire. Cela détermine de quel type de parenthèse il s'agit, en donnant un 1 s'il s'agit d'une parenthèse exclusive et un 0 s'il s'agit d'une parenthèse inclusive.

a=s<42;

Enfin, nous affichons le produit de la gamme souhaitée:

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

Le produit est composé de nombres commençant par le premier nombre s(2)plus le premier type de parenthèse a(1)(qui est un 1 s'il s'agit d'une parenthèse exclusive), allant jusqu'au deuxième nombre inclus, s(3)moins le deuxième type de parenthèse a(4). Cela donne la gamme inclusive / exclusive correcte.

— Tom Carpenter
source
1

Julia, 75 octets

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

Il s'agit d'une fonction anonyme qui accepte une chaîne et renvoie un entier. Pour l'appeler, donnez-lui un nom, par exemplef=s->... .

Non 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.
source
1

Mathematica, 128 octets

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

C'est trop long ... Je pense actuellement à une solution StringReplace+ RegularExpression.

— LegionMammal978
source
0

PowerShell, 146 104 octets

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

Golfed off 42 octets en modifiant la façon dont les nombres sont extraits de l'entrée. Courtiser!

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
source
0

Perl 6 , 60 octets

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

Il y a un peu de mauvaise correspondance car la façon dont vous écririez l' (2,5]exemple en Perl 6 serait 2^..5( [2^..5]fonctionne également).
Je dois donc échanger (2avec [2^, et ,avec .., puis je dois le faire EVALdans une plage.

usage:

# 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
source
0

CJam, 34 octets

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

Essayez-le en ligne

Explication:

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
source
0

JavaScript (ES6), 90 octets

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

Explication

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

Tester

Afficher l'extrait de code

— user81655
source
0

R, 102 104 octets

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

Non 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])
}

modifier pour autoriser les nombres négatifs [au détriment de 2 caractères supplémentaires

— mnel
source
Langue?
— ThisSuitIsBlackNot
@ThisSuitIsBlackNot - R(et corrigé dans la réponse)
— mnel
0

JavaScript (ES6), 79

Comme méthode anonyme

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

Extrait de test

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>
Développer l'extrait

— edc65
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.