introduction

L'une des premières choses que j'ai apprises en chimie a été de donner la formule de combustion des alcanes. L'exemple le plus basique était: 2CH4 + 4O2 > 4H2O + 2CO2. Notez que l'équation aurait pu être simplifiée en divisant chaque coefficient par 2, nous obtiendrions CH4 + 2O2 > 2H2O + CO2 . Pour faciliter les choses, nous allons ignorer cette étape .

Vous pouvez voir qu'avec la combustion de n'importe quel alcane, l'oxygène est utilisé. Après la réaction, seuls du CO2 et du H2O sont produits.

La tâche:

Donnez un programme complet qui prend en entrée STDIN ou l'équivalent le plus proche possible, et génère la réaction totale en utilisant STDOUT ou l'équivalent le plus proche possible.

L'entrée sera toujours sous la forme C(n)H(2n+2), avec n > 0. Voici quelques exemples d'entrées:

CH4
C2H6
C3H8
C4H10
C5H12
C6H14

etc.

Un conseil utile:

Chaque alcane a un schéma standard dans la réaction de combustion:

2C(n)H(2n+2) + (3n+1)O2 > (2n+2)H2O + (2n)CO2

par exemple

C4H10donne l'équation suivante: 2C(4)H(2*4+2) + (3*4+1)O2 > (2*4+2)H2O + (2*4)CO2. Après avoir tout calculé, nous obtenons cette équation finale:2C4H10 + 13O2 > 10H2O + 8CO2

Exemples:

input:  CH4
output: 2CH4 + 4O2 > 4H2O + 2CO2

input:  C3H8
output: 2C3H8 + 10O2 > 8H2O + 6CO2

input:  C4H10
output: 2C4H10 + 13O2 > 10H2O + 8CO2

input:  C12H26
output: 2C12H26 + 37O2 > 26H2O + 24CO2

Règles:

• Vous devez fournir un programme complet.
• Votre programme doit prendre la contribution de STDIN, ou l'équivalent le plus proche si ce n'est pas possible.
• Votre programme doit sortir en utilisant STDOUT, ou l'équivalent le plus proche si ce n'est pas possible.
• Notez que j'ai utilisé des espaces pour les exemples pour augmenter la lisibilité, ceux-ci ne sont pas nécessaires . 2CH4 + 4O2 > 4H2O + 2CO2et 2CH4+4O2>4H2O+2CO2sont deux sorties valides. Cependant, si vous utilisez régulièrement des espaces pour la sortie, vous obtenez un bonus de -10%
• C'est du code-golf , donc le programme avec le moins d'octets gagne!

Pyth, 40 octets

s[2z\+h*3Jv|hctz\H\1"O2>"yhJ"H2O+"yJ"CO2

Essayez-le en ligne. Suite de tests.

Python 3, 86 * 0,9 = 77,4 octets

s=input()
N=int(s.split('H')[1])
print("2%s + %dO2 > %dH20 + %dCO2"%(s,N*1.5-2,N,N-2))

Extrait le nombre de Hplutôt que le nombre deC s de l'entrée. Cela évite la casse spéciale CH4et simplifie les expressions de sortie en termes de N=2n+2.

La sortie a des paramètres connectés via le formatage des chaînes. Le premier summand est juste la chaîne d'entrée, et les autres ont des nombres calculés branchés. Notez que N*1.5-2(identique à N*3/2-2) donne un flottant, mais le formatage de la chaîne le convertit en entier.

Java, 0,9 * 202 = 181,8 octets

Parfois, je me demande si je me blesse simplement avec Java.

Merci à @TNT et @TFeld d'avoir rasé 20 bons octets!

classe A {public static void main (String [] a) {String s = a [0] .substring (1, a [0] .indexOf ("H")); long n = Long.parseLong ((s.length) ()> 0)? S: "1"); System.out.printf ("2% s +% dO2>% dH2O +% dCO2", a [0], 3 * n + 1,2 * n + 2 , 2 * n);}}

Assez simple. Fondamentalement, je coupe l'entrée de Cà Het j'obtiens cette sous-chaîne. Si ce n'est rien, je m'en mets nà un. Sinon, je le mets au nombre entre CetH . Le code suivant l'imprime et le met en notation appropriée.

Non golfé:

Classe A{
    public static void main (String [] a) {
         String s = a [0] .substring (1, a [0] .indexOf ("H"));
         long n = Long.parseLong ((s.length ()> 0)? s: "1");
         System.out.printf ("2% s +% dO2>% dH2O +% dCO2", a [0], 3 * n + 1,2 * n + 2,2 * n);
    }
}

Python 2, 122 91 * 0,9 = 81,9 octets

i=input()
n=2*int(i[1:i.find('H')]or 1)
print'2%s + %dO2 > %dH2O + %dCO2'%(i,n*3/2+1,n+2,n)

Javascript ES6, 63 * .9 = 56,7 octets

_=>`2${_} + ${$=_.split`H`[1],$*1.5-2}O2 > ${$}H2O + ${$-2}CO2`

Similaire à ma réponse ESMin.

Pyth, 69 octets * 0,9 = 62 63 * 0,9 = 57 56 * 0,9 = 50 53 * 0,9 = 48 octets

Js>z+xz\H1s[\2z%" + %dO2 > %dH2O + %dCO2"[-*1.5J2J-J2

C'est comme la réponse de xnor, où j'utilise les valeurs H. Une variable J est utilisée pour stocker la quantité de H dans la formule moléculaire de la molécule.

Essayez-le ici

Javascript ES6, 96 * 0,9 = 86,4

f=s=>`2C${(n=(s.match(/\d+(?!.*\d)/)[0]-2))>2?n/2:''}H${n+2} + ${1.5*n+1}O2 > ${n+2}H2O + ${n}CO2`

CJam, 45 44 octets

2r_'H/1=[i_((_2/1$+)@@]"+%dO2>%dH2O+%dCO2"e%

Essayez-le en ligne

Pour éviter les boîtiers spéciaux CH4, je n'utilise pas du tout le premier chiffre, et j'extrais seulement le nombre après le H. Cela donne la valeur de 2n+2. Les valeurs restantes sont ensuite calculées sur cette base et formatées.

Explication:

2       Push leading 2 for output.
r       Get input.
_'H/    Copy and split at 'H.
1=      Take second part after split, this is 2n+2.
[       Start list.
  i       Convert string value to integer.
  _((     Copy and decrement twice, giving 2n.
  _2/     Copy and divide by 2, giving n.
  1$      Copy the 2n to the top.
  +       Add, to get 3n.
  )       Increment, giving 3n+1. We now have 2n+2, 2n, 3n+1 on stack.
  @@      Rotate top 3 entries twice, to get 3n+1, 2n+2, 2n.
]       Close list.
"+%dO2>%dH2O+%dCO2"
        Format string for output.
e%      "printf" operator.

Perl, (84 + 1) * 0,9 = 76,5

(+1 car pour courir avec le -n drapeau)

Mon premier golf Perl!

@x=(1,m/C(\d)/g);$n=$x[$#x];say"2$_ + ".(3*$n+1)."O2 > ".(($n*=2)+2)."H20 + ${n}CO2"

Il est important que STDIN ne contienne pas de nouvelle ligne de fin. Exemple d'utilisation:

llama@llama:...code/perl/ppcg64412chemistry$ printf CH4 | perl -n chemistry.pl
2CH4 + 4O2 > 4H20 + 2CO2

Ungolfed-ish:

#!/usr/bin/perl
use 5.10.0;

$_ = 'C3H8';
my @x = (1, m/C(\d)/g);
my $n = $x[$#x];
say "2$_ + ".(3*$n+1)."O2 > ".(($n*=2)+2)."H20 + ${n}CO2";

Les lignes

my @x = (1, m/C(\d)/g);
my $n = $x[$#x];

sont assez intéressants ici. $#xreprésente le "dernier index peuplé" de @x(et la mise en évidence de la syntaxe de SE pense que c'est un commentaire parce qu'il est stupide), donc $x[$#x]sélectionnera la partie capturée de l' C(\d)expression régulière si elle existe, ou 1autrement. (Perl ne se soucie pas que ce soit une chaîne dans tous les autres cas sauf 1; vous pouvez très bien utiliser les opérateurs numériques sur les chaînes en Perl.)

JS, 118 (106) octets

x=prompt();y=x.replace("CH","C1H").match(/\d{1,}/g)[0];alert(2+x+" + "+(3*y+1)+"O2 > "+(2*y+2)+"H2O + "+(2*y)+"CO2");

𝔼𝕊𝕄𝕚𝕟, 51 * .9 = 45,9 caractères / 64 * .9 = 57,6 octets

a=ïČ`H”[1],`2⦃ï} + ⦃a*1.5-2}O2 > ⦃a}H2O + ⦃a-2}CO2`

Try it here (Firefox only).

Explication

a=ïČ`H”[1],      // split input along H to get 2n+2
`  2⦃ï}          // 2C(n)H(2n+2) – this is the same as 2[input alkane's formula]
   + ⦃a*1.5-2}O2 // + 2(3n+1)O2
   > ⦃a}H2O      // > (2n+2)H2O
   + ⦃a-2}CO2    // + (2n)O2
`                // implicitly output the template string above

Python, 0,9 * 195 = 175 0,9 * 190 = 171 0,9 * 148 = 133 octets

i=raw_input()
O=3*int(i[1:i.find('H')]or 1)+1;C=2*int(i[1:i.find('H')]or 1);print"2"+i+" + "+`O`+"O2"+" > "+i[i.find('H')+1:]+"H2O"+ " + "+`C`+"CO2"

Essayez-le ici

F #, 113

let s=stdin.ReadLine()
float s.[1+s.IndexOf 'H'..]|>fun f->printf"2%s + %gO2 > %gH2O + %gCO2"s<|f*1.5-2.<|f<|f-2.

MATLAB, 96 * 0,9 = 86,4 octets

s=input('');i=[sscanf(s,'C%dH'),1];n=i(1);fprintf('%s + %dO2 > %dH2O + %dCO2',s,3*n+1,2*n+2,2*n)

Assez explicite. Prend une chaîne d'entrée (besoin de la mettre entre guillemets pour que MATLAB n'essaye pas de l'exécuter!). Convertit ensuite le nombre entre le C et le H dans l'entrée en décimal. La valeur 1 est ajoutée sous forme de tableau à la sortie de sscanf de sorte que dans le casCH4 où nous extrayons le premier index du tableau dans nnous obtenons un 1 s'il n'y avait pas de nombre entre le C et le H. Ensuite, il suffit de l'imprimer avec les espaces suivant la formule de la question.

Cela devrait également fonctionner avec Octave en utilisant l'interpréteur en ligne ici .

C ++, 160 * 0,9 = 144 octets

#include<iostream>
int main(){int n=1,t;std::cin.get();std::cin>>n;t=2*n;printf("2C");n-1&&printf("%i",n);printf("H%i + %iO2 > %iH2O + %iCO2",t+2,t+n+1,t+2,t);}

Un peu plus que ce à quoi je m'attendais. Lit d'abord le caractère et le supprime, puis lit l'int et affiche le résultat. Le problème est avecn être 1. Je ne peux pas penser à un moyen plus court de le produire.

Non golfé

#include <iostream>
int main()
{
    int n = 1, t;
    std::cin.get();
    std::cin >> n;
    t = 2 * n;
    printf("2C");
    n - 1 && printf("%i", n);
    printf("H%i + %iO2 > %iH2O + %iCO2", t + 2, t + n + 1, t + 2, t);
}

Clojure / ClojureScript, 98 * 0,9 = 88,2 octets

#(let[n(max 1(int((re-find #"C(.*)H"%)1)))m(* 2 n)](str "2"%" + "(inc(* 3 n))"O2 > "(+ 2 m)"H2O + "m"CO2"))

Crée une fonction anonyme. Essayez-le en allant ici et en entrant (def f #(let...)), alors (f "C3H8").

Excel, 123 * 0,9 = 110,7 octets

=="2"&A1&" + "&(3*MID(A1,FIND("H",A1)+1,9)/2-2)&"O2 > "&MID(A1,FIND("H",A1)+1,9)&"H2O + "&(MID(A1,FIND("H",A1)+1,9)-2)&"CO2"

Si nous pouvions prendre l'entrée CH4 comme C1H4, peut être réduite à 122 * 0,9 = 109,8 octets

="2"&A1&" + "&3*MID(A1,2,FIND("H",A1)-2)+1&"O2"&" > "&MID(A1,FIND("H",A1)+1,9)&"H2O + "&(MID(A1,FIND("H",A1)+1,9)-2)&"CO2"

Gelée , 33 octets

ṣ”HṪVµ2³”+2⁸_©+H“O2>”⁸“H2O+”®“CO2

Essayez-le en ligne!

Le bonus n'aide pas ici.