परिचय

रसायन विज्ञान में मैंने जो पहली चीजें सीखीं, उनमें से एक थी अल्कान के दहन का सूत्र। सबसे बुनियादी उदाहरण था: 2CH4 + 4O2 > 4H2O + 2CO2। ध्यान दें कि हर गुणांक को 2 से विभाजित करके समीकरण को सरल बनाया जा सकता है, हमें मिलेगा CH4 + 2O2 > 2H2O + CO2 । चीजों को आसान बनाने के लिए, हम इस कदम को अनदेखा करने जा रहे हैं ।

आप देख सकते हैं कि किसी भी अल्केन के दहन के साथ, ऑक्सीजन का उपयोग किया जाता है। प्रतिक्रिया के बाद, केवल CO2 और H2O बनाए जाते हैं।

काम:

एक पूरा कार्यक्रम दें जो एसटीडीआईएन या निकटतम संभव समकक्ष से इनपुट लेता है, और एसटीडीटी या निकटतम संभव समकक्ष का उपयोग करके कुल प्रतिक्रिया को आउटपुट करता है।

इनपुट हमेशा रूप में होगा C(n)H(2n+2)साथ n > 0। ये कुछ उदाहरण इनपुट हैं:

CH4
C2H6
C3H8
C4H10
C5H12
C6H14

etc.

एक उपयोगी टिप:

हर एल्केन का दहन प्रतिक्रिया में एक मानक पैटर्न होता है:

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

जैसे

C4H10निम्नलिखित समीकरण देता है 2C(4)H(2*4+2) + (3*4+1)O2 > (2*4+2)H2O + (2*4)CO2:। सब कुछ गणना करने के बाद, हमें यह अंतिम समीकरण मिलता है:2C4H10 + 13O2 > 10H2O + 8CO2

उदाहरण:

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

नियम:

आपको एक पूर्ण कार्यक्रम प्रदान करने की आवश्यकता है।
यदि संभव न हो तो आपके कार्यक्रम को STDIN, या निकटतम समकक्ष से इनपुट लेना होगा।
यदि संभव न हो तो आपके प्रोग्राम को STDOUT, या निकटतम समकक्ष का उपयोग करके आउटपुट की आवश्यकता है।
ध्यान दें कि मैंने पठनीयता बढ़ाने के लिए उदाहरणों के लिए रिक्त स्थान का उपयोग किया, ये आवश्यक नहीं हैं । 2CH4 + 4O2 > 4H2O + 2CO2और 2CH4+4O2>4H2O+2CO2दोनों वैध आउटपुट हैं। हालांकि, यदि आप लगातार आउटपुट के लिए रिक्त स्थान का उपयोग करते हैं , तो आपको एक -10% बोनस मिलता है
यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीतने वाला कार्यक्रम जीत जाता है!

code-golf chemistry

— अदनान
स्रोत

पूरी तरह से अलग लेकिन संबंधित: ड्राइंग लुईस स्ट्रक्चर्स ऑफ अल्कनेस

— नॉट

तो हम मान सकते हैं कि इनपुट सही फॉर्मूला होगा?

— तन्मात्रा

@ तन्माथ, हाँ, आपको अमान्य फ़ार्मुलों के बारे में चिंता करने की ज़रूरत नहीं है

— अदनान

"लगातार रिक्त स्थान का उपयोग करें" - लगातार 0 स्थान गणना का उपयोग करेगा?

— मीगो

1

@ मेगो, नहीं। 0 रिक्त स्थान का उपयोग करना रिक्त स्थान का उपयोग नहीं कर रहा है, इसलिए नियम लागू नहीं होता है

— अदनान

1

अजगर, 40 बाइट्स

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

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

— PurkkaKoodari
स्रोत

7

पायथन 3, 86 * 0.9 = 77.4 बाइट्स

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

इनपुट से Hसंख्या की बजाय अर्क की संख्या निकालता है C। यह विशेष-आवरण से बचता है CH4और उत्पादन के भाव को सरल बनाता है N=2n+2।

आउटपुट में स्ट्रिंग स्वरूपण के माध्यम से प्लग किए गए पैरामीटर हैं। पहला सारांश केवल इनपुट स्ट्रिंग है, और बाकी की गणना की गई संख्याओं को प्लग इन किया गया है। ध्यान दें कि N*1.5-2(समान N*3/2-2) एक फ़्लोट देता है, लेकिन स्ट्रिंग स्वरूपण इसे एक इंट में बदल देता है।

— XNOR
स्रोत

4

जावा, 0.9 * 202 = 181.8 बाइट्स

कभी-कभी, मुझे आश्चर्य होता है कि क्या मैं सिर्फ जावा के साथ खुद को चोट पहुंचा रहा हूं।

एक अच्छा 20 बाइट्स शेविंग करने के लिए @TNT और @TFeld को धन्यवाद!

वर्ग A {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग []] {स्ट्रिंग s = a [0]। ()> 0)? S: "1"); System.out.printf ("2% s +% dO2>% dH2O +% dCO2", एक [0], 3 * n + 1,2 * n + 2 , 2 * एन);}}

बहुत साधारण। असल में, मैं से इनपुट में कटौती Cकरने के लिए H, और कहा कि सबस्ट्रिंग मिलता है। अगर यह कुछ भी नहीं है, तो मैं nएक पर सेट हूं । अन्यथा, मैं इसे के बीच संख्या के लिए सेट Cऔर H। निम्नलिखित कोड केवल इसे प्रिंट करता है और इसे उचित अंकन में डालता है।

Ungolfed:

कक्षा{
    सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग [] ए) {
         स्ट्रिंग s = [a 0] .substring (1, [a]] .indexOf ("H"));
         long n = Long.parseLong ((s.length ()> 0)? s: "1");
         System.out.printf ("2% s +% dO2>% dH2O +% dCO2", एक [0], 3 * n + 1,2 * n + 2,2 * n);
    }
}

— एडिसन क्रम्प
स्रोत

2

अच्छा जवाब है, लेकिन आपको एसटीडीआईएन का उपयोग करना चाहिए न कि कमांड लाइन आर्ग्स का। हालाँकि, अगर आप सही तरीके से गिने जाते हैं तो आप अपने कच्चे स्कोर से (-11 के printfबजाय) का उपयोग करके इसे छोटा कर सकते हैं +।

— टीएनटी

मुझे बताया गया है कि कमांड लाइन तर्कों का उपयोग STDIN के लिए एक स्वीकार्य विकल्प है। इसके अलावा, क्या आप स्पष्ट कर सकते हैं कि आप मेरे लिए उपयोग करने के लिए क्या मतलब है printf? (उस पर थोड़ा सा नकचढ़ा, पहले इसका इस्तेमाल नहीं किया।: डी)

— एडिसन क्रम्प

printfसे यांत्रिकी का उपयोग करता है java.util.Formatter। आपके पास अपने प्रिंट स्टेटमेंट में "% d" जैसे प्रिंट करने के लिए एक स्ट्रिंग हो सकती है और इसके बाद कुछ वैल्यू या वेरिएबल होगा जो इसके बजाय प्रिंट होगा। यह उन स्थितियों में उपयोगी हो सकता है जहां आपके पास मुद्रित करने के लिए बहुत सारे चर हैं, उदाहरण के लिए ।

— टीएनटी

और यह तथ्य कि एसटीडीआईएन के स्थान पर कमांड लाइन तर्क स्वीकार्य है, मेरे लिए नई (और बल्कि सहायक) खबर है। :)

— TNT

1

@VoteToClose हाँ, आप अपने आप को जावा से पीड़ित कर रहे हैं।

— क्रिकटी लिथोस

4

पायथन 2, 122 91 * 0.9 = 81.9 बाइट्स

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)

— TFeld
स्रोत

3

जावास्क्रिप्ट ईएस 6, 63 * .9 = 56.7 बाइट्स

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

मेरे ESMin उत्तर के समान।

— मामा फन रोल
स्रोत

3

पायथ, 69 बाइट्स * 0.9 = 62 63 * 0.9 = 57 56 * 0.9 = 50 53 * 0.9 = 48 बाइट्स

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

यह सिर्फ एक्सनॉर के जवाब की तरह है, जहां मैं एच मूल्यों का उपयोग करता हूं। एक चर J का उपयोग अणु के आणविक सूत्र में H की मात्रा को संग्रहीत करने के लिए किया जाता है।

इसे यहाँ आज़माएँ

— TanMath
स्रोत

आप रिक्ति पर छह बाइट्स खर्च करते हैं, लेकिन बोनस से केवल पांच बाइट्स प्राप्त करते हैं, इसलिए यह इसके लायक नहीं है।

— lirtosiast

2

जावास्क्रिप्ट ईएस 6, 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`

— Dendrobium
स्रोत

2

CJam, 45 44 बाइट्स

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

इसे ऑनलाइन आज़माएं

विशेष आवरण से बचने के लिए CH4, मैं पहले नंबर का उपयोग बिल्कुल नहीं करता हूं, और उसके बाद ही नंबर निकालता हूं H। का मान देता है 2n+2। शेष मानों की गणना उसके आधार पर और स्वरूपित की जाती है।

स्पष्टीकरण:

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.

— रेटो कोराडी
स्रोत

2r_[[~]W=_2/(3*)\_2-]"+%dO2>%dH2O+%dCO2"e%एक बाइट बचाता है।

— डेनिस

2

पर्ल, (84 + 1) * 0.9 = 76.5

( -nध्वज के साथ चलने के लिए +1 चार )

मेरा पहला पर्ल गोल्फ!

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

यह महत्वपूर्ण है कि STDIN में एक अनुगामी नई रेखा न हो। उदाहरण का उपयोग:

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";

रेखाएं

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

यहाँ काफी दिलचस्प हैं। (और एसई के वाक्यविन्यास को उजागर करने $#xवाले "अंतिम आबादी वाले सूचकांक" का प्रतिनिधित्व करता @xहै यह सोचता है कि यह एक टिप्पणी है क्योंकि यह गूंगा है), इसलिए रेगेक्स $x[$#x]के कैप्चर किए गए हिस्से का चयन करेंगे यदि यह मौजूद है, या अन्यथा। (पर्ल को इस बात की कोई परवाह नहीं है कि यह सिवाय अन्य सभी मामलों में एक स्ट्रिंग होगा ; आप पर्ल में बस स्ट्रिंग पर संख्यात्मक ऑपरेटरों का उपयोग कर सकते हैं।)C(\d)11

— Doorknob
स्रोत

1

जेएस, 118 (106) बाइट्स

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");

— नॉटिलस
स्रोत

1

।, 51 * .9 = 45.9 चार्ट / 64 * .9 = 57.6 बाइट्स

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

Try it here (Firefox only).

व्याख्या

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

— मामा फन रोल
स्रोत

जो कोई भी मेरे उत्तर को अस्वीकार कर देता है, क्या मुझे स्पष्टीकरण मिल सकता है?

— मामा फन रोल

1

पायथन, 0.9 * 195 = 175 0.9 * 190 = 171 0.9 * 148 = 133 बाइट्स

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"

इसे यहाँ आज़माएँ

— TanMath
स्रोत

आपको printएक "वर्ण के बीच के स्थान की आवश्यकता नहीं है , और CO2चर को कुछ छोटा नाम दिया जा सकता है :)

— अंडरग्राउंडोरेल

@undergroundmonorail धन्यवाद

— तन्माथ

चूंकि या i[1]तो "H"एक अंक होने की गारंटी है , आप 58 से 71 के साथ एक अन्य बाइट को बचा सकते हैं if i[1]>"9"(या "9"किसी अन्य चरित्र के साथ एससीआई मान के साथ बदल सकते हैं )

— भूमिगत

1

एफ #, 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.

— Sehnsucht
स्रोत

1

MATLAB, 96 * 0.9 = 86.4 बाइट्स

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)

काफी हद तक आत्म व्याख्यात्मक। एक इनपुट स्ट्रिंग लेता है (इसे उद्धरण चिह्नों में लपेटने की आवश्यकता है ताकि MATLAB इसे निष्पादित करने का प्रयास न करे!)। फिर दशमलव में इनपुट में C और H के बीच की संख्या को परिवर्तित करता है। मान 1 को sscanf के आउटपुट में एक सरणी के रूप में जोड़ा जाता है ताकि मामले में CH4जब हम सरणी में पहला इंडेक्स निकालेंn 1 प्राप्त हो यदि C और H के बीच कोई संख्या नहीं थी। तो बस रिक्त स्थान के साथ प्रिंट करता है। प्रश्न में सूत्र का पालन करना।

यह भी यहाँ ऑनलाइन दुभाषिया का उपयोग कर ओक्टेव के साथ काम करना चाहिए ।

— टॉम बढ़ई
स्रोत

1

सी ++, 160 * 0.9 = 144 बाइट्स

#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);}

थोड़ा और जो मुझे उम्मीद थी। पहले चार को पढ़ता है और उसे छोड़ देता है, फिर int पढ़ता है और परिणाम को आउटपुट करता है। समस्या n1 होने के साथ है । मैं इसे आउटपुट करने के छोटे तरीके के बारे में नहीं सोच सकता।

Ungolfed

#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);
}

— Zereges
स्रोत

1

क्लोजर / क्लोजुरस्क्रिप्ट, 98 * 0.9 = 88.2 बाइट्स

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

एक अनाम फ़ंक्शन बनाता है। यहाँ जाकर और (def f #(let...))फिर, दर्ज करके देखें (f "C3H8")।

— MattPutnam
स्रोत

1

एक्सेल, 123 * 0.9 = 110.7 बाइट्स

=="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"

यदि हम सीएच 4 इनपुट को सी 1 एच 4 के रूप में ले सकते हैं, तो इसे 122 * 0.9 = 109.8 बाइट्स तक कम किया जा सकता है

="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"

— Wernisch
स्रोत

0

जेली , 33 बाइट्स

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

इसे ऑनलाइन आज़माएं!

बोनस यहाँ मदद नहीं करता है।

— आउटगोल्फ को एरिक करें
स्रोत

केमिस्ट्री क्लास में वापस