रोसेटा स्टोन चैलेंज: एक श्रृंखला के लिए नियम का पता लगाएं

15

रोजेटा स्टोन चैलेंज का लक्ष्य अधिक से अधिक भाषाओं में समाधान लिखना है। अपनी प्रोग्रामिंग बहुभाषिकता दिखाएं!

चुनौती

आपकी चुनौती एक ऐसे कार्यक्रम को लागू करना है जो संख्याओं की एक सूची को इनपुट करेगा और श्रृंखला में प्रत्येक क्रमिक संख्या उत्पन्न करने के लिए उपयोग किए जाने वाले नियम का उत्पादन करेगा, जितनी संभव हो उतनी प्रोग्रामिंग भाषाओं में । आपको किसी भी प्रकार के मानक पुस्तकालय फ़ंक्शन का उपयोग करने की अनुमति है जो आपकी भाषा में है, क्योंकि यह ज्यादातर एक भाषा शोकेस है।

एक "श्रृंखला" क्या है?

एक श्रृंखला पूर्णांकों की एक क्रमबद्ध सूची है। श्रृंखला में प्रत्येक क्रमिक संख्या को श्रृंखला में पिछले नंबर पर एक सरल नियम लागू करके उत्पन्न किया जा सकता है। इस चुनौती में, नियम में संख्या को एक स्थिरांक से गुणा करना और फिर दूसरा स्थिरांक जोड़ना शामिल है। दोनों स्थिरांक किसी भी पूर्णांक हो सकते हैं। इस चुनौती का लक्ष्य उन दो स्थिरांक का उत्पादन करना है।

श्रृंखला के लिए 2 5 11, नियम के रूप में लिखा जा सकता है 2 1। इसका मतलब है कि प्रत्येक संख्या पिछली संख्या, 2 बार, प्लस 1 है। एक महत्वपूर्ण तथ्य यह है कि अधिकांश श्रृंखलाओं में एक नियम है। कुछ श्रृंखलाओं में या तो एक अनंत संख्या है या कोई भी नहीं है, लेकिन आपको इससे निपटना नहीं होगा।

इनपुट

इनपुट तीन अलग-अलग पूर्णांकों की एक सूची होगी जो अनुक्रम में संख्याएं हैं। नंबर या तो स्थान, अल्पविराम, या न्यूलाइन सीमांकित हो सकते हैं, लेकिन कृपया निर्दिष्ट करें कि कौन सा। मैं इस सीमा पर लचीला होने जा रहा हूं क्योंकि कुछ भाषाओं में इनपुट प्रतिबंध हो सकते हैं। यहाँ इनपुट के चार उदाहरण दिए गए हैं:

0 7 14
2 5 11
2 0 -4
5 -19  77

उत्पादन

आउटपुट दो पूर्णांक होंगे जो श्रृंखला उत्पन्न करने के लिए उपयोग किए जाने वाले नियम का प्रतिनिधित्व करते हैं। पहला नंबर गुणक स्थिर होगा, जबकि दूसरा नंबर एडिटिव स्थिरांक होगा। आउटपुट का स्वरूपण स्थान, अल्पविराम, या न्यूलाइन सीमांकित हो सकता है। मैं इस सीमा पर भी लचीला हूं। यहां आउटपुट के संबंधित उदाहरण दिए गए हैं:

1 7
2 1
2 -4
-4 1

उद्देश्य जीत का मानदंड

एक उद्देश्य जीतने वाली कसौटी के रूप में, यहाँ यह है: प्रत्येक भाषा एक अलग प्रतियोगिता है, जो सबसे छोटी प्रविष्टि लिख सकती है, लेकिन समग्र विजेता वह व्यक्ति होगा जो इन उप-प्रतियोगिताओं में सबसे अधिक जीतता है। इसका मतलब यह है कि कई असामान्य भाषाओं में जवाब देने वाला व्यक्ति लाभ प्राप्त कर सकता है। किसी भाषा में एक से अधिक समाधान होने पर कोड-गोल्फ अधिकतर एक टाईब्रेकर होता है: सबसे छोटे कार्यक्रम वाले व्यक्ति को उस भाषा का श्रेय दिया जाता है।

नियम, प्रतिबंध और नोट्स

आपका कार्यक्रम 9 अप्रैल 2012 से पहले मौजूद किसी भी भाषा में लिखा जा सकता है। मुझे कुछ अधिक असामान्य / गूढ़ भाषाओं में लिखी गई कुछ प्रतिक्रियाओं को मान्य करने के लिए समुदाय पर निर्भर रहना होगा, क्योंकि मैं परीक्षण करने में सक्षम नहीं हूं। उन्हें।

वर्तमान लीडरबोर्ड

यह खंड समय-समय पर भाषाओं की संख्या दिखाने के लिए अद्यतन किया जाएगा और प्रत्येक में कौन अग्रणी है।

  • AWK (32) - मेलमोकब
  • बैश (31) - पीटर टेलर
  • Befunge (29) - हावर्ड
  • बीसी (39) - कर्नेल
  • ब्रेनफक (174) - सीएमपी
  • सी (78) - l0n3_shArk
  • सी ++ (96) - वामावर्तबाउट
  • आम लिस्प (88) - कर्नेल
  • क्रे चैपल (59) - काइल कानोस
  • csh (86) - कर्नेल
  • कूडा (301) - वामावर्तबाउट
  • डीसी (30) - केर्नह
  • डॉस बैच (54) - मेलमोकब
  • तत्व (27) - हावर्ड
  • es (95) - कर्नेल
  • कारक (138) - कर्नेल
  • फेलिक्स (86) - kirbyfan64sos
  • फोरट्रान (44) - काइल कानोस
  • गो (101) - हावर्ड
  • गोल्फस्क्रिप्ट (16) - हावर्ड
  • गोल्फलुआ (44) - काइल कानोस
  • हास्केल (35) - लेफ्टरनैबाउट
  • जे (23) - गैरेथ
  • जावा (141) - हावर्ड
  • जावास्क्रिप्ट (47) - मेलमोकब
  • जूलिया (71) - एमएल
  • लुआ (51) - हावर्ड
  • पारा (319) - लेफ्टरनैबाउट
  • मूनस्क्रिप्ट (48) - kirbyfan64sos
  • निमरॉड (146) - लेफ्टरनैबाउट
  • उल्लू (22) - रेस
  • पास्कल (88) - लेफ्टरनैबाउट
  • पर्ल (57) - गैरेथ
  • PHP (61) - मेलमोकब
  • PicoLisp (72) - कर्नेल
  • पीटर (56) - एमएल
  • पोस्टस्क्रिप्ट (61) - हावर्ड
  • अजगर (40) - हावर्ड
  • क्यू (36) - tmartin
  • QBasic (34) - मेलमोकब
  • आर (50) - रेस
  • रूबी (44) - हावर्ड
  • स्काला (102) - गैरेथ
  • एसक्यूएल (57) - अमन ज़ीके वर्मा
  • TI-83 बेसिक (25) - मेलमोकब
  • असीमित रजिस्टर मशीन (285) - पैक्सिनम
  • VBA (57) - गफ्फी
  • व्हॉट्सएप (123) - रेस
  • zsh (62) - कर्नेल

वर्तमान उपयोगकर्ता रैंकिंग

समान रैंक को वर्णानुक्रम में क्रमबद्ध किया जाता है।

  1. हॉवर्ड (9): बेफ्यूज (29), एलिमेंट (27), गो (101), गोल्फक्राफ्ट (16), जावा (141), लूआ (51), पोस्टस्क्रिप्ट, (61) पायथन, (40) रूबी (44)

  2. kernigh (8): bc (39), कॉमन लिस्प (88), csh (86), dc (30), es (95), फैक्टर (138), PicoLisp (72), zsh (62)

  3. बायीं ओरबाउटआउट (6): सी ++ (96), कूडा (301), हास्केल (35), बुध (319), निमरोड (146), पास्कल (88)

  4. मेलमोकब (6): एडब्ल्यूके (32), डॉस बैच (54), जावास्क्रिप्ट (47), पीएचपी (61), क्यूबेसिक (34), टीआई -83 बेसिक (41)

  5. गैरेथ (3): जे (23), पर्ल (57), स्काला (102)

  6. काइल कानोस (3): क्रे चैपल (59), फोरट्रान (44), गोल्फलुआ (44)

  7. रेस (3): उल्लू (22), आर (50), व्हाट्सप (123)

  8. kirbyfan64sos (2): फेलिक्स (86), मूनस्क्रिप्ट (48)

  9. एमएल (2): जूलिया (71), पिट (56)

  10. अमन ज़ीक वर्मा (1): एसक्यूएल (57)

  11. सीएमपी (1): ब्रेनफक (174)

  12. गफ्फी (1): वीबीए (57)

  13. l0n3_shArk (1): C (78)

  14. Paxinum (1): असीमित रजिस्टर मशीन (285)

  15. पीटर टेलर (1): बैश (31)

  16. tmartin (1): क्यू (36)

code-golf  math  rosetta-stone 
— PhiNotPi
स्रोत
ऐसा नहीं लगता है कि लोग वास्तव में टैग, या अन्य विवरण पढ़ते हैं ...
— काउंटरक्ल्विस को चालू करने के लिए बंद हो गया
@leftaroundabout: आप ऐसा क्यों कहते हैं? मुझे पता है (उदाहरण के लिए) कि मेरा समाधान सरणी इनपुट नहीं लेता है और बाद में इसे ठीक करने की योजना बना रहा है। और मैं इस समय एक से अधिक समाधान पोस्ट करने के लिए बहुत आलसी हूं।) वस्तु विजेता मानदंड के अनुसार, कोड-गोल्फ एक ही भाषा के साथ दो पदों के लिए टाई-ब्रेकर है, इसलिए मैंने आसान के लिए वर्ण गणना शामिल की है। मामले में संदर्भ किसी और जावास्क्रिप्ट समाधान पोस्ट करता है। यह वास्तव में उन दुर्लभ क्षणों में से एक हो सकता है जब एक प्रश्न दोनों code-golf और code-challenge टैग के योग्य हो ।
— मेलमोकब
हाँ, आप सही हैं: किसी को असामान्य भाषाएं भी नहीं करनी हैं।
— को बंद करना
3
जब तक आप वर्तमान लीडरबोर्ड को ऊपर के समान मानक प्रारूप में रखते हैं, तब तक आप इसका उपयोग प्रत्येक उपयोगकर्ता के स्कोर को उत्पन्न करने के लिए कर सकते हैं: jsfiddle.net/bk2WM/2
— mellamokb
1
मेरा नवीनतम संस्करण ( jsfiddle.net/bk2WM/4 ) एक कच्चे आउटपुट (टेक्स्टारिया में) आप एक पोस्ट में कॉपी / पेस्ट कर सकते हैं, और इसे प्रारूपित कर सकते हैं जैसे मैंने अपनी पोस्ट में किया था। लेआउट के साथ बदलने / खेलने के लिए स्वतंत्र महसूस करें।
— मेलमोकब

जवाबों:

9

GolfScript, 16 अक्षर

~1$- 1$3$-/.p@*-

इनपुट को अंतरिक्ष-पृथक सूची के रूप में दिया गया है।

जावास्क्रिप्ट, 56 वर्ण

p=prompt;x=alert;a=p();b=p();x(m=(p()-b)/(b-a));x(b-a*m)

इनपुट प्रॉम्प्ट पर दिया गया है।

रूबी, 44 अक्षर

a,b,c=eval("[#{gets}]");m=c-b;p m/=b-a,b-m*a

इनपुट यहां अल्पविराम से अलग की गई सूची के रूप में दिया गया है।

पायथन, 40 अक्षर

a,b,c=input();m=c-b;m/=b-a;print m,b-m*a

इनपुट फिर से अल्पविराम से अलग हो गया है।

जावा, 141 अक्षर

enum E{E;static int s(){return new java.util.Scanner(System.in).nextInt();}{int a=s(),b=s(),m=s()-b;m/=b-a;System.out.print(m+" "+(b-a*m));}}

न्यूलाइन द्वारा इनपुट अलग किया गया।

लुआ, 51 वर्ण

r=io.read
a,b=r(),r()
m=(r()-b)/(b-a)
print(m,b-m*a)

न्यूलाइन द्वारा इनपुट अलग किया गया।

गो, 101 वर्ण

package main
import"fmt"
var a,b,c int
func main(){fmt.Scan(&a,&b,&c)
c-=b
c/=b-a
fmt.Print(c,b-a*c)}

न्यूलाइन द्वारा इनपुट अलग किया गया।

फोरट्रान, 90 वर्ण

      PROGRAM X
      READ(*,*)I,J,K
      K=(K-J)/(J-I)
      WRITE(*,*)K,J-I*K
      END

न्यूलाइन द्वारा इनपुट अलग किया गया।

Befunge, 29 वर्ण

&01p&:11p:&-01g11g-/:.01g*-.@

पोस्टस्क्रिप्ट, 61 अक्षर

2 5 14
1 index sub 1 index 3 index sub idiv dup = 3 2 roll mul sub =

उल्लू, 23 वर्ण

<%<%<$-1`4'-/%.32)2'*-.

न्यूलाइन द्वारा इनपुट अलग किया गया।

तत्व , २ 27 वर्ण

_-a;_3:'-_+"a~+/2:`a~*+\ ``

न्यूलाइन द्वारा इनपुट अलग किया गया।

— हावर्ड
स्रोत
मेरे जावास्क्रिप्ट समाधान के बेशर्म
— वारिस
1
खैर दो इस खेल को खेल सकते हैं ...: पी
— mellamokb
@ ममलमोकब अच्छा है। लेकिन मैंने पहले ही आपके जवाब को बढ़ा दिया;; तो हमारे लिए क्या बचा है: 48 पात्रों को हराया ...
— हावर्ड
2
वाह, आपने मेरी भाषा में गपशप की। मैं सम्मानित महसूस करता हूँ। मैं भी तुम्हें हराने के लिए विवश महसूस करता हूँ। :)
— PhiNotPi
1
आपके तत्व समाधान के बारे में, ऐसा प्रतीत होता है कि अंतिम `चिह्न की आवश्यकता नहीं है। क्या यह आपकी ओर से एक त्रुटि है या मेरे दुभाषिया में कोई त्रुटि है जिसे मैंने पास्टबीन पर पोस्ट किया है? ओह, और मेरे पास एक 27 चरित्र समाधान है।
— PhiNotPi
8

ब्रेनफक - 174

,>,>,<[>->+>+<<<-]>>>[<<<+>>>-]<<<<[>>>->+<<<<-]>>>>[<<<<+>>>>-]<<[->-
[>+>>]>[+[-<+>]>+>>]<<<<<]>>>[<<<+>>>-]<[-]<[-]<.[>>+<<-]>>[<<<<[>>+>+
<<<-]>>>[<<<+>>>-]>-]<<[<->-]<.

Piet - 82?

यकीन नहीं है कि यहां प्रतिस्पर्धी गोल्फ कैसे मापें। मैं कुल छवि आकार (कोड्स में) के साथ जा रहा हूँ मेरा 41x2 है: यहां छवि विवरण दर्ज करें

Befunge - 34

&00p&10p&10g-10g00g-/:.00g*10g\-.@

अंग्रेजी - 278

The multiplier is the quotient of the difference of the second 
and third values and the second and first values. 
To generate a new term, multiply the current term by the multiplier
and add the difference of the first value and the product of the 
multiplier and the second value.

यकीन नहीं है कि अगर यह मायने रखता है, लेकिन मुझे लगा कि मैं इसे एक शॉट दूंगा। एक साधारण एल्गोरिथ्म का भी सटीक वर्णन करना कठिन है। Kinda इच्छा अंग्रेजी पूर्वता स्थापित करने के लिए कुछ प्रकार के समूहीकरण प्रतीक का समर्थन किया।

— captncraig
स्रोत
मुझे एक दुभाषिया से लिंक करें (एक पूर्ण एक जो पूरी भाषा को समझता है, और इस समस्या को हल करने की दिशा में सिर्फ सक्षम नहीं है) और मैं इसे स्वीकार कर सकता हूं।
— फीनोटपी
— captncraig
1
यह ठीक है, एक अन्य व्यक्ति ने लाटेक्स में गणितीय प्रमाण लिखा है। यह गिनती नहीं था, लेकिन विविधता में जोड़ता है।
— PhiNotPi
अगर मैं npiet के साथ आपके Piet समाधान की कोशिश करता हूं तो मुझे यह परिणाम मिलता है: D:\Software\Programming\Piet\npiet-1.3a-win32>npiet series2.png ? 5 ? -19 ? 77 05 समाधान होना चाहिए-4 1
— ML
आपके द्वारा पोस्ट की गई छवि तब तक काम नहीं करती है जब तक कि आप इसे एक पिक्सेल से नहीं बढ़ाते हैं (न कि कोडेल!) दाईं ओर। 461 पिक्सेल 11 से विभाज्य नहीं हैं, जो कि एक असामान्य कोडेल आकार है, जिस तरह से;)
— ML
8

QBasic, 42

INPUT "",a,b,c
m=(c-b)/(b-a)
PRINT m;b-m*a

अल्पविराम के साथ इनपुट की आवश्यकता होती है, रिक्त स्थान के साथ आउटपुट (क्या यह ठीक है?)

बुध, ३१ ९

:-module r.
:-interface.
:-import_module io,list,int,char,string.
:-pred main(io::di,io::uo)is det.
:-implementation.
main(!IO):-io.read_line_as_string(J,!IO),(if J=ok(I),[A,B,C]=list.map(string.det_to_int,string.words_separator(char.is_whitespace,I)),M=(C-B)/(B-A)then io.format("%d %d",[i(M),i(B-M*A)],!IO)else true).

हास्केल, 85 81

f[a,b,c]|m<-(c-b)`div`(b-a)=[m,b-m*a]
main=getLine>>=mapM_ print.f.map read.words

अब रिक्त स्थान के साथ इनपुट, नईलाइन के साथ आउटपुट।

सी, 80

main(a,b,c,m){scanf("%d %d %d",&a,&b,&c);m=(c-b)/(b-a);printf("%d %d",m,b-m*a);}

सी ++, 96

#include<iostream>
main(){int a,b,c,m;std::cin>>a>>b>>c;m=(c-b)/(b-a);std::cout<<m<<' '<<b-m*a;}

निमरोड, १४६

import strutils
var
 q:array[0..3,int]
 b,m:int
for i in 0..2:q[i]=ParseInt(readLine(stdin))
b=q[1]
m=(q[2]-b)div(b-q[0])
echo($m,",",$(b-m*q[0]))

इनपुट w / newlines, आउटपुट अल्पविराम।

यह कोई गिनती नहीं करेगा, लेकिन मुझे लगता है कि यह अभी भी किसी तरह से फिट बैठता है:

गणितीय प्रमेय, लाटेक्स के 713 अक्षर

\documentclass{article}\usepackage{amsmath}\usepackage{amsthm}\begin{document}Theorem: for a sequence $(a_i)_i$ of integers with $a_2\neq a_1$ where $a_3-a_2$ is divisible by $a_2-a_1$, $m:=\frac{a_3-a_2}{a_2-a_1},\ p:=a_2-m\cdot a_1$ give rise to a sequence\[b_i:=\begin{cases}a_1&\text{for }i=1\\b_{i-1}\cdot m+p&\text{else}\end{cases}\] such that $b_i=a_i\ \forall i\leq 3$.

Proof: $i=1$ is trivial,\[\begin{aligned}b_2=&b_1\cdot m+p=a_1\frac{a_3-a_2}{a_2-a_1}+a_2-\frac{a_1a_3-a_1a_2}{a_2-a_1}=a_2,\\b_3=&b_2\cdot m+p=\frac{a_2a_3-a_2^2}{a_2-a_1}+a_2-\frac{a_1a_3-a_2^2}{a_2-a_1}\\=&\frac{a_2a_3-a_1a_3+(a_2-a_1)a_2-a_2^2+a_1a_2}{a_2-a_1}\\=&\frac{a_2-a_1a_3+0}{a_2-a_1}=a_3.\end{aligned}\]\qed\end{document}

LaTeX गणितीय-प्रमेय समाधान का आउटपुट

जबकि हम :=परिभाषाएँ लिख रहे हैं ...

पास्कल, 90 88

program r;var a,b,c:integer;begin;read(a,b,c);c-=b;c:=c div(b-a);write(c,' ',b-c*a);end.

कुडा, 301

#include<stdio.h>
__global__ void r(int*q){if(!(blockIdx.x|threadIdx.x)){q[1]-=*q;q[1]/=(*q-q[2]);*q-=q[1]*q[2];}}
main(){int p[3],*q;scanf("%d%d%d",p+2,p,p+1);cudaMalloc(&q,24);cudaMemcpy(q,p,24,cudaMemcpyHostToDevice);r<<<1,1>>>(q);cudaMemcpy(p,q,24,cudaMemcpyDeviceToHost);printf("%d %d",p[1],*p);}
— काउंटरक्लॉक को चालू करना बंद कर दिया
स्रोत
1
आप सी समाधान में दो चार्ट को समाप्त करके mऔर पुन: उपयोग करके बचा सकते हैं c, और एक दो को c-=b;c/=b-a;इसके बजाय का उपयोग करके c=(c-b)/(b-a);।
— पीटर टेलर
सी समाधान में, आपको scanf()प्रारूप स्ट्रिंग में रिक्त स्थान की आवश्यकता नहीं है ।
— रेटो कोराडी
7

AWK, 35 वर्ण

{m=($3-$2)/($2-$1);print m,$2-$1*m}
  • इनपुट प्रारूप: 2 0 -4

ई.पू., ३ ९ अक्षर

define f(a,b,c){
m=(c-b)/(b-a)
m
b-a*m}
  • इनपुट प्रारूप: z=f(2, 0, -4)
  • इनपुट एक bcअभिव्यक्ति है। bcस्रोत फ़ाइल पढ़ने के बाद , यह मानक इनपुट पढ़ता है। यही कारण है कि इनपुट को फ़ंक्शन कॉल की तरह दिखना चाहिए।
  • मैं OpenBSD का उपयोग करता हूं bc, जिसके बाद एक नई लाइन की आवश्यकता होती है {।

कॉमन लिस्प, 88 वर्ण

(let*((a(read))(b(read))(c(read))(m(/(- c b)(- b a))))(format
t "~A ~A" m (- b(* a m))))
  • इनपुट प्रारूप: 2 0 -4

csh, 86 वर्ण

set i=(`cat`)
@ m=($i[3] - $i[2]) / ($i[2] - $i[1])
@ n=$i[2] - $i[1] * $m
echo $m $n
  • इनपुट प्रारूप: 2 0 -4
  • फ़ाइल के अंत में 86 वां वर्ण नया है। cshएकमात्र ऐसी भाषा है जिसके लिए मैं फ़ाइल के अंत में नई पंक्ति गिनता हूँ। ऐसा इसलिए है क्योंकि cshजब तक newline नहीं होता तब तक अंतिम कमांड कभी नहीं चलती है।
  • set i=($<)काम नहीं करता है, क्योंकि $<कोई शब्द विभाजन नहीं है।

डीसी, 30 अक्षर

?scsbsalclb-lbla-/psmlblalm*-p
  • इनपुट प्रारूप: अंडरस्कोर 2 0 _4कहां _है।

तों, 95 वर्ण

i=(`cat)
b=$i(2)
m=`{expr \( $i(3) - $b \) / \( $b - $i(1) \)}
echo $m `{expr $b - $i(1) \* $m}
  • इनपुट प्रारूप: 2 0 -4
  • esहै एक्स्टेंसिबल खोल पॉल Haahr और बायरन Rakitzis द्वारा।

कारक, 138 वर्ण

USING: eval formatting io kernel locals math ;
contents eval( -- a b c ) [let :> ( a b c )
c b - b a - / dup a * b swap - "%d %d" printf ]
  • इनपुट प्रारूप: 2 0 -4

पिको लिस्प, 74 72 वर्ण

(in()(let(r read a(r)b(r)c(r)m(/(- c b)(- b a)))(print
m (- b(* a m)))))
  • इनपुट प्रारूप: 2 0 -4
  • संपादित करें: बदलकर 2 वर्ण खो a(read)b(read)c(read)दिए r read a(r)b(r)c(r)।

TI-83 बेसिक, 63 61 वर्ण

:Input A
:Input B
:Input C
:(C-B)/(B-A)→M
:Disp M
:Disp B-A*M
  • इनपुट प्रारूप: 2ENTER 0ENTER ¯4ENTER करें, जहाँ ¯कैलकुलेटर का यूनीरी माइनस है।
  • मैंने यूनिकोड वर्णों को गिना; →(दायां तीर) U + 2192 के रूप में गिना जाता है। उदाहरण के लिए, कैलकुलेटर मायने रखता हैInput A 2 वर्णों के रूप में जाता है, लेकिन मैं Input A7 वर्णों के रूप में गिनता हूं । मैं भी :1 चरित्र के रूप में गिना जाता हूं ।
  • संपादित करें: मैंने दुस्साहस किया: ६१ हैं, ६३ नहीं, वर्ण हैं।

zsh, 62 वर्ण

i=(`cat`)
((b=i[2],m=(i[3]-b)/(b-i[1]),n=b-i[1]*m))
echo $m $n
  • इनपुट प्रारूप: 2 0 -4
— kernigh
स्रोत
7

AWK (32)

{m=$3-$2;print m/=$2-$1,$2-$1*m}

डेमो: http://ideone.com/kp0Dj

बैश (38)

awk '{m=$3-$2;print m/=$2-$1,$2-$1*m}'

डेमो: http://ideone.com/tzFi8

डॉस / बैट (54 55 )

set/a m=(%3-%2)/(%2-%1)&set/a n=%2-%m%*%1&echo %m% %n%

तर्कों की अंतरिक्ष-पृथक सूची के रूप में पैरामीटर लेता है।

जावा (143 185 )

enum R{R;{int a=0,b=0,c,i=2;for(;(c=new java.util.Scanner(System.in).nextInt()+b*--i)+i>=c;b=c)a+=c*i;c/=b-a;System.out.print(c+" "+(b-a*c));}}

जावास्क्रिप्ट (48 61 67 )

p=prompt;m=p(b=p(a=p()))-b;alert([m/=b-a,b-a*m])

डेमो: http://jsfiddle.net/BT8bB/6/

PHP (61 77 )

<?list(,$a,$b,$c)=$argv;$c-=$b;echo($c/=$b-$a).' '.$b-=$c*$a;

डेमो: http://ideone.com/CEgke

QBasic (34)

INPUT a,b,c
m=(c-b)/(b-a)
?m;b-m*a

TI-83 बेसिक (25 41 )

:Prompt A,B,C
:(C-B)/(B-A
:Disp Ans,B-AAns

हां, गुम सही कोष्ठक उद्देश्य पर है। यह एक प्रसिद्ध अनुकूलन तकनीक है जो TI-83 बेसिक प्रोग्रामिंग में STO ऑपरेशन से पहले कोष्ठकों को बंद करना आवश्यक नहीं है।

— mellamokb
स्रोत
1
JS एक फ़ायरफ़ॉक्स में मेरे लिए काम नहीं करता है - मुझे एक त्रुटि मिलती है जो pअपरिभाषित है। क्या जेएस कल्पना कहती है कि फ़ंक्शन का समाधान करने से पहले फ़ंक्शन तर्कों का मूल्यांकन किया जाना चाहिए?
— पीटर टेलर
हम्म। हाँ आप सही हैं। युक्ति के अनुसार, यह काम नहीं करना चाहिए, जैसा कि इस तरह के एसओ प्रश्न में समझाया गया है: stackoverflow.com/questions/9941736/… । उनके तर्कों का मूल्यांकन करने से पहले कार्यों को बाध्य किया जाना चाहिए, और Chrome जाहिरा तौर पर इसे रिवर्स ऑर्डर में करता है।
— मेलामोकब
मैंने लंबे और कठिन प्रयास करके उच्चतम जावा समाधान को पूरी तरह से अलग दृष्टिकोण से हरा दिया है जिसे आप ऊपर देख सकते हैं। 143 मैं प्राप्त करने में सक्षम निकटतम है। किसी को भी कोई विचार है, कृपया अपना रास्ता भेजें!
— मेलमोकब
6

व्हॉट्सएप, 123

I / O न्यूलाइन-सेपरेटेड है। (स्रोत कोड प्राप्त करने के लिए, संपादन मोड दर्ज करें और प्रीफ़ॉर्मेट टैग्स के बीच व्हाट्सएप कॉपी करें; या, आइडोन पर ऑनलाइन उदाहरण देखें ।)

स्पष्टीकरण, जहां एस, टी, एल अंतरिक्ष, टैब, लाइनफ़ीड का प्रतिनिधित्व करता है:

Pseudocode     Whitespace
----------     ----------
push 0         SS SSL
readn          TLTT
push 1         SS STL
readn          TLTT
push 2         SS STSL
dup            SLS
readn          TLTT
retr           TTT
push 1         SS STL
retr           TTT
-              TSST
push 1         SS STL
retr           TTT
push 0         SS SSL
retr           TTT
-              TSST
/              TSTS
dup            SLS
outn           TLST
push 10        SS STSTSL
outc           TLSS
push 0         SS SSL
retr           TTT
*              TSSL
push 1         SS STL
retr           TTT
swap           SLT
-              TSST
outn           TLST
exit           LLL

आर, ५०

x=scan(n=3);y=diff(x);z=y[2]/y[1];c(z,x[2]-x[1]*z)

I / O अंतरिक्ष-पृथक है।

उल्लू

--- 22 ---

< <%<-2`2`-/%.10)2'*-.

I / O न्यूलाइन-सेपरेटेड है।

--- 19 --- (यदि इस संस्करण की अनुमति है, लेकिन मुझे लगता है कि यह धोखा है, क्योंकि \ निष्पादन योग्य कोड है):

1`-1`3`-/%.32)2'*-.

I / O अंतरिक्ष-पृथक है। कमांड-लाइन उपयोग: owl prog 5 19\ 77(उल्लू में एक उपसर्ग रहित शून्य के रूप में कार्य करता है)।

— रेस
स्रोत
आपकी उल्लू प्रविष्टि के साथ, मैं आपके 19 char समाधान के निर्णय को स्थगित कर सकता हूं क्योंकि आपका 22 char समाधान पहले से ही भाषा के लिए जीत रहा है।
— फीनोटपी
5

जे, 23 अक्षर

(],1{x-0{x*])%~/2-/\x=:

उपयोग:

   (],1{x-0{x*])%~/2-/\x=: 5 _19 77
_4 1

नकारात्मक अंक जे में अंडरस्कोर द्वारा दर्शाए जाते हैं।

PHP, 88 वर्ण

<?php
list($x,$y,$z)=split(' ',fgets(STDIN));
$a=($z-$y)/($y-$x);
echo$a." ".($y-$a*$x);

स्काला, 102 वर्ण

val x=readLine.split(" ").toList.map(_.toInt)
val a=(x(2)-x(1))/(x(1)-x(0))
print(a+" "+(x(1)-x(0)*a))

पर्ल, 57 वर्ण

s!(.+) (.+) (.+)!$a=($3-$2)/($2-$1);$a." ".($2-$1*$a)!e

'-P' विकल्प की आवश्यकता है, जिसके लिए मैंने 2 वर्ण जोड़े हैं। मान लेता है कि इनपुट कुछ वर्णों को सहेजने के लिए मान्य है।

मेरे सभी जवाब अंतरिक्ष से अलग संख्या लेते हैं।

— गैरेथ
स्रोत
जे कार्यक्रमों के बारे में ... क्या इनपुट को उपयोगकर्ता से संकेत करने के बजाय सीधे स्रोत फ़ाइल में कोडित करने की अनुमति है?
— रेस
@res मैंने इसे वैसे ही दिया है जैसे मैं इसे कमांड लाइन पर लागू करता हूं। 1!:1]3अभिव्यक्ति के दाईं ओर जोड़ने से STDIN से इनपुट पढ़ा जाएगा। मुझे लगता है कि मेटा पर या कुछ जे के जवाबों पर टिप्पणियों में चर्चा हुई है कि यह अनुमति दी जानी चाहिए या नहीं। मैं कुछ हद तक महत्वाकांक्षी हूं - मुझे यह पता लगाने में मजा आता है कि जे को कैसे प्राप्त करना है जो मैं सबसे छोटी जगह में चाहता हूं, मैं एसटीडीआईएन से इनपुट के लिए 6 कैरेक्टर पेनल्टी लूंगा अगर वह सब चाहते हैं।
— गारेथ
मैं सोच रहा था कि अगर यह J की अनुमति है, तो कुछ अन्य प्रविष्टियों को इसी तरह छोटा किया जा सकता है। (BTW, मैं काम करने के लिए आपके सुझाए गए अभिव्यक्ति को प्राप्त नहीं कर सका, लेकिन (],1{x-0{x*])%~/2-/\x=:".1!:1]1कंसोल मोड में ठीक लगता है।)
— Res
@ अरे ओह, मैं एक स्ट्रिंग से संख्या की सूची में बदलना भूल गया (हालांकि अंत में 3 सामान्य रूप से मेरे लिए ठीक है?)
— गैरेथ
यदि आप एक पूर्ण कार्यक्रम के बजाय पर्ल को एक सबरूटीन बनाते हैं, तो आप इसे 50 बाइट्स तक नीचे ($a=($_[1]-pop)/($_[0]-$_[1])).$/.($_[1]-$_[0]*$a)
— ला
4

PHP, 74,72 , 69

<?fscanf(STDIN,'%d%d%d',$a,$b,$c);echo($d=($c-$b)/($b-$a)).' '.($b-$d*$a);

जब इनपुट को तर्कों के रूप में पारित किया जाता है:

<?echo($d=($argv[3]-$argv[2])/($b=$argv[2]-$a=$argv[1])).' '.($b-$d*$a);

अब, जैसा कि @mellamokb ने सुझाव दिया, $ n = $ argv का उपयोग करके:

<?$n=$argv;echo($d=($n[3]-$n[2])/($b=$n[2]-$a=$n[1])).' '.($b-$d*$a);

सी, 77 , 78

main(a,b,c,d){printf("%d %d",d=(c-b)/(b-a),b-d*a,scanf("%d%d%d",&a,&b,&c));}

^ ऐसा काम नहीं करता है, यहाँ सामान है: [सूचना के लिए इसे लाने के लिए @ यूगोरन को धन्यवाद]

main(a,b,c,d){printf("%d %d",d,b-a*(d=(c-b)/(b-a)),scanf("%d%d%d",&a,&b,&c));}
— l0n3sh4rk
स्रोत
+1 वाह, पता नहीं था कि आप fscanfऔर scanfरिक्त स्थान के बिना कर सकते हैं । बहुत बढ़िया!
— मेलामोकब
1
अपने दूसरे PHP सॉल्यूशन में, आप शुरुआत में $argv, नाम बदलकर , कुछ और अक्षर नहीं बचा सकते थे $n=$argv?
— मेलमोकब
@ मेलमोकब- हाँ! मैंने उसके बारे में नहीं सोचा था! धन्यवाद! :)
— l0n3sh4rk
आपका सी कोड काम नहीं करता (मैंने लिनक्स पर कोशिश की)। मैं एक बहुत ही अजीब पैरामीटर मूल्यांकन आदेश पर निर्भर करता हूं - scanfपहले क्यों किया जाएगा, d=..फिर b-d*a?
— बदसूरत
1
मैं जो बता सकता हूं, यह सबसे अधिक वातावरण (उदा: ideone.com/I2cPg ) में काम करने के लिए सिर्फ "मनमाने ढंग से" होता है , लेकिन सी में पैरामीटर मूल्यांकन का क्रम अपरिभाषित व्यवहार है, और इसलिए तकनीकी रूप से इस पर भरोसा नहीं किया जाना चाहिए: Orangejuiceliberationfront .com /…
— मेलमोकब
3

VBA, 57 वर्ण

Sub x(a,b,c)
y=(c-b)/(b-a)
MsgBox y & " " & b-a*y
End Sub

( यह मूल रूप से अन्य 'बुनियादी' कार्यों के समान है, लेकिन मुझे पहले से ही वहां कोई VBA सबमिशन दिखाई नहीं दिया। )

— Gaffi
स्रोत
आप लाइन 3 सेDebug.?y;b-a*y
— टेलर स्कॉट
3

यह बिना बताए गए रजिस्टर मशीन के लिए (गैर-अनुकूलित) कोड है, यहां वर्णित है: http://www.proofwiki.org/wiki/Definition :Unlimited_Register_Machine

इनपुट रजिस्टर 1,2 और 3 में होना चाहिए, और आउटपुट प्रोग्राम 1 के बाद रजिस्टर 1, 2 में होगा। गैर-नकारात्मक और गैर-पूर्णांक संख्या को संभाला नहीं जाता है, लेकिन इनपुट 0,7,14 और 2,5,11 सही ढंग से संभाला जाता है।

Zero[8] Trans[2,11] Jump[3,11,7] Succ[11] Succ[8] Jump[11,11,3] Zero[5] Trans[1,12] Jump[2,12,13] Succ[12] Succ[5] Jump[12,12,9] Zero[17] Trans[8,13] Jump[13,17,25] Zero[16] Trans[5,14] Jump[13,14,22] Succ[14] Succ[16] Jump[14,14,18] Succ[9] Trans[16,13] Jump[17,17,15] Zero[6] Zero[20] Jump[9,6,40] Zero[7] Trans[1,21] Jump[20,7,36] Succ[21] Trans[21,19] Trans[19,21] Succ[7] Jump[7,7,30] Trans[21,18] Trans[18,20] Succ[6] Jump[6,6,27] Trans[20,4] Zero[10] Trans[4,15] Jump[2,15,47] Succ[15] Succ[10] Jump[15,15,43] Trans[9,1] Trans[10,2]

EDIT: कोष्ठक हटाकर, और निर्देश नामों को छोटा करके:

यूआरएम 285

Z8 T2,11 J3,11,7 S11 S8 J11,11,3 Z5 T1,12 J2,12,13 S12 S5 J12,12,9 Z17 T8,13 J13,17,25 Z16 T5,14 J13,14,22 S14 S16 J14,14,18 S9 T16,13 J17,17,15 Z6 Z20 J9,6,40 Z7 T1,21 J20,7,36 S21 T21,19 T19,21 S7 J7,7,30 T21,18 T18,20 S6 J6,6,27 T20,4 Z10 T4,15 J2,15,47 S15 S10 J15,15,43 T9,1 T10,2

— प्रति अलेक्जेंडरसन
स्रोत
(+1) लेकिन ... "गैर-नकारात्मक और गैर-पूर्णांक संख्या को संभाला नहीं जाता है" ... मुझे लगता है कि आपके कहने का मतलब है कि नकारात्मक संख्या को संभाला नहीं गया है। (ओ पी का कहना है सभी इनपुट और आउटपुट पूर्णांक है।)
— रेस
आह, यह नहीं पढ़ा कि आउटपुट पूर्णांक था ...
— प्रति अलेक्जेंडरसन
क्या मुझे इसे चरित्र गणना या निर्देशों की संख्या से गिनना चाहिए?
— PhiNotPi
हो सकता है कि संपादित संस्करण में वर्णों की गणना करें ...
— प्रति अलेक्जेंडर्सन
3

डॉस-बैच, 98

@ECHO OFF&SET/P p=&SET/P q=&SET/P r=&SET/A m=(%r%-%q%)/(%q%-%p%)&SET/A n=%q%-%p%*%m%&ECHO %m% %n%

अलग लाइनों में इनपुट

बैश, 51

m=$((($3 - $2)/($2 - $1)))
echo $m $(($2 - $m*$1))

उदाहरण : sh prog.sh 2 0 -4 (अंतरिक्ष अलग तर्क)

पर्ल, 84

@s=split(/ /,&lt;STDIN&gt;);$m=($s[2]-$s[1])/($s[1]-$s[0]);print $m." ".($s[1]-$s[0]*$m);

जावा, 297

import java.util.*;public class A{public static void main(String a[]){StringTokenizer s=new StringTokenizer(new Scanner(System.in).nextLine());int i=4;int[] p=new int[i];while(i-->1)p[3-i]=Integer.parseInt(s.nextToken());p[3]=(p[2]-p[1])/(p[1]-p[0]);System.out.print(p[3]+" "+(p[1]-p[0]*p[3]));}}

स्पेस अलग इनपुट, स्पेस अलग आउटपुट।

एसक्यूएल, 57

select (&3-&2)/(&2-&1),&2-((&3-&2)/(&2-&1)*&1) from dual

यह एक दुखद प्रविष्टि है, लेकिन 'सिर्फ' उद्देश्य को हल करता है। क्वेरी रनटाइम पर इनपुट को बांधता है 1,2,3 इनपुट के क्रम में चर हैं।

— अमन ज़ीके वर्मा
स्रोत
हालांकि अन्य लोग आपके bashसमाधान को हरा चुके हैं, मैं सिर्फ यह सुझाव देना चाहता था कि आप उन सभी अतिरिक्त स्थानों को हटा सकते हैं और 6 पात्रों को बचा सकते हैं।
— मेलमोकब
धन्यवाद mellamokb, मुझे एहसास हुआ कि, मैं बाद में इसे नजरअंदाज कर दिया। इसके अलावा, मुझे अपने डॉस / बैच समाधान के बारे में नहीं सोचने से खुद से नफरत है, जिसे मेरे सिर पर क्लिक करना चाहिए था..हर्स आह!
— अमन जीके वर्मा
2

क्यू, ३६

{a,x[2]-x[1]*a:%[x[2]-x 1;x[1]-x 0]}

प्रयोग

q){a,x[2]-x[1]*a:%[x[2]-x 1;x[1]-x 0]}each(0 7 14;2 5 11;2 0 -4;5 -19 77)
1  7 
2  1 
2  -4
-4 1
— tmartin
स्रोत
2

फोरट्रान 44

read*,i,j,k;k=(k-j)/(j-i);print*,k,j-i*k;end

इनपुट एक ही लाइन में होगा (अल्पविराम या अलग किया गया स्थान)

क्रे चैपल 59

var i,j,k:int;read(i,j,k);k=(k-j)/(j-i);write(k," ",j-i*k);

इनपुट सिंगल लाइन पर होगा, कोई भी नई लाइन ( writelnजगह के लिए उपयोग करके उस के लिए 2 वर्ण जोड़ें)write )।

गोल्फलुआ ४४

r=I.r;a,b=r(),r();m=(r()-b)/(b-a);w(m,b-m*a)

न्यूलाइन सीमांकित इनपुट, अंतरिक्ष सीमांकित आउटपुट

— काइल कानोस
स्रोत
2

जूलिया, 71 वर्ण

अंतरिक्ष सीमांकित इनपुट और आउटपुट।

i,j,k=int(split(readline(STDIN)));println("$(l=div(k-j,j-i)) $(j-i*l)")

उदाहरण इनपुट और आउटपुट:

julia> i,j,k=int(split(readline(STDIN)));println("$(l=div(k-j,j-i)) $(j-i*l)")
5 -19 77
-4 1

पीट, 86 60 बेहतर दृश्यता के लिए 56 कोडेल (14x4), कोडेल आकार 10

मैं वास्तव में 35% तक कोडल्स की मात्रा को कम कर सकता था। मुझे इस तरह के अच्छे परिणाम की उम्मीद नहीं थी। इस कार्यक्रम को पीछे की ओर ले जाना, जैसा कि मुझे उम्मीद थी, काफी सफल रहा। मुझे संदेह है कि यह इससे छोटा हो सकता है, लेकिन मुझे वास्तव में दिलचस्पी होगी अगर कोई भी एक छोटा समाधान खोज सकता है।

चुनौती यह नहीं बताती है कि यदि परिणाम दिखाने के बाद कार्यक्रम को रोकना है, तो मेरा सबसे छोटा (56 कोडेल) कार्यक्रम मान्य होना चाहिए। यह केवल परिणाम दिखाने के बाद शुरुआत में वापस आ जाता है, पूर्णांक के एक नए ट्रिपल के लिए पूछ रहा है। तंग पैकिंग के कारण दो न्यूलाइन वर्णों के आउटपुट के लिए कोई जगह नहीं है, लेकिन यह npiet दुभाषिया के साथ कोई समस्या नहीं है, क्योंकि यह हमेशा एक 'प्रिंट करता है?' अगर यह इनपुट का इंतजार कर रहा है।

लूप किए गए संस्करण को बनाने के लिए दो संभावित आकार हैं, लेकिन एक संस्करण जो केवल एक बार चलता है वह केवल एक प्रोग्राम में संभव है जो कम से कम 64 कोडल (16x4) बड़ा है। नीचे दिए गए संस्करण इसका कारण बताते हैं। शायद यह उन लोगों के लिए भी दिलचस्प है जो पीट से परिचित हैं।

एक लूप के साथ अंतिम, सबसे कसकर पैक 56 कोडेल संस्करण :

एक श्रृंखला 56 कोड के लिए नियम खोजें

दूसरा संस्करण (60 कोडल्स), एक लूप के साथ

एक श्रृंखला 60 कोड के लिए नियम खोजें

यदि 56 कोडेल संस्करण नियमों के विरुद्ध है, तो अंतिम 64 कोडेल संस्करण है, केवल एक बार चल रहा है :

एक श्रृंखला 64 के लिए नियम खोजें, एक बार चलाएं

मेरा पहला संस्करण (86 कोडेल)

एक श्रृंखला 86 कोड के लिए नियम खोजें

इनपुट और आउटपुट न्यूलाइन किए गए हैं।

उदाहरण इनपुट और आउटपुट:

D:\codegolf\npiet-1.3a-win32>npiet ml_series.png
? 5
? -19
? 77
-4
1

लूप किए गए संस्करणों के लिए, थोड़ा बदसूरत दिखना:

D:\codegolf\npiet-1.3a-win32>npiet ml_series_56_codels.png"
? 5
? -19
? 77
-4
1? 5
? -19
? 77
-4
1? 5
? -19
? 77
-4
1?

मैंने सीमांकक के रूप में नई रेखा को चुना क्योंकि ASCII 10 (\ n) कोडिंग को ASCII 32 () की तुलना में स्पष्ट रूप से केवल 7 कोडल्स की आवश्यकता है, जिसे 8 कोडल्स या यहां तक ​​कि ASCII 40 (,) की आवश्यकता है, जिसे 9 कोडल्स की आवश्यकता है।

पहले इनपुट के परिणाम से पीछे की ओर कोडिंग करना सीआरओ संचालन के लिए कोडेल उपयोग को कम करने का एक शानदार तरीका है। शुरुआत में और अंत में स्टैक ऑर्डर ज्ञात हैं, बाकी आसानी से हाथ से किया जाता है।

यहाँ मेरा बनाया आशुलिपि में 64 कोडेल कार्यक्रम (स्टैक के साथ) का एक पाठ संस्करण है। छोटे कार्यक्रम अभी समाप्त नहीं होते हैं, लेकिन शुरुआत में लूप वापस आ जाते हैं।

NOP ADD DIV GRT DUP INC END
 0   +   /   >   =   c   ~
PSH SUB MOD PTR ROL OUN
 X   -   %   #   @   N
POP MUL NOT SWI INN OUC
 ?   *   !   $   n   C

                   1
        1    1   2 2     1                   a,b,c: input for series
      5 5  3 3 c c cb  3 3                       D: c-b
    b b bb b bbb b bcD D Da                      E: b-a
   bb b bb b baa a aaa a abE F                   F: D/E, (c-b)/(b-a), mul. const.
  bbb b ba a abb b bbb b bDDFFF    5             G: a*F, a(c-b)/(b-a)
 aaaa a aa a aaa a aaa a aaaaaaG  55 10          H: b-G, b-a*F, add. const.
aaaaa a ab b bbb b bbb b bbbbbbbH HH  H H
n=n==5X1X@3X1X@n2X1X@-3X1X@-/=N*-5X=  + CN~
| |            |     |     || |||\____/ ||
| |            |     |     || |||  |    |+———— output add. const.
| |            |     |     || |||  |    +————— output newline character
| |            |     |     || |||  +—————————— 5 DUP + =10, ASCII for \n
| |            |     |     || ||+————————————— H, add. const.
| |            |     |     || |+—————————————— G
| |            |     |     || +——————————————— output mul. const.
| |            |     |     |+————————————————— F, mul. const.
| |            |     |     +—————————————————— E
| |            |     +———————————————————————— D
| |            +—————————————————————————————— input c
| +——————————————————————————————————————————— input b
+————————————————————————————————————————————— input a
— एमएल
स्रोत
1

MoonScript (48 वर्ण, न्यूलाइन सीमांकित इनपुट, स्पेस सीमांकित आउटपुट)

r=io.read
a,b=r!,r!
m=(r!-b)/(b-a)
print m,b-m*a

फेलिक्स (86 वर्ण, न्यूलाइन सीमांकित इनपुट, कॉमा सीमांकित आउटपुट)

gen r()=>int $ readln stdin;
var a,b=r(),r();
var m=(r()-b)/(b- a);
println(m,b- m*a);

जूलिया (84 वर्ण, अंतरिक्ष सीमांकित इनपुट, अंतरिक्ष सीमांकित आउटपुट)

a,b,c=tuple(map(int,split(readline(STDIN)))...)
m=(c-b)/(b-a)
println("$m $(b-m*a)")
— kirbyfan64sos
स्रोत
आपका जूलिया समाधान एक त्रुटि फेंकता है। त्रुटि: tuple.jl पर अनुक्रमित_नेक्स्ट में BoundsError (): 19 (2 बार दोहराता है) d: \ codegolf \ Series.jl को लोड करते समय, लाइन 1 पर शुरू होने वाली अभिव्यक्ति में
— ML
@ एमएम अजीब है। कुछ ऐसा हो सकता है जो जूलिया के नवीनतम संस्करण में बदल गया हो। मैं इसे आजमाऊंगा।
— kirbyfan64sos
अगर मैं इसे कंसोल में आज़माता हूँ तो मुझे पहली पंक्ति के तुरंत बाद त्रुटि मिलती है। किसी तरह लाइन एक टपल बनाता है, यह हमेशा (ए, बी, 0) है। अगर मैं इसे एक .jl फ़ाइल के माध्यम से शामिल करता हूं तो यह आउटपुट बनाता है, लेकिन अगर मैं जूलिया REPL को वापस पाने के लिए एंटर दबाता हूं, तो यह त्रुटि को फेंक देता है। julia> शामिल ("happy_birthday_codegolf.jl") 5 -19 77 -4 1 ERROR: BoundsError () tuple.jl पर indexed_next में: 19 (दोहराव 2 बार) d: \ codegolf \ Series.jl को लोड करते समय, अभिव्यक्ति शुरू होने पर। लाइन 1 क्या टिप्पणियों में लाइन ब्रेक डालने का कोई तरीका है? गंदगी के लिए खेद है।
— एमएल
@ML क्या इसे किसी फ़ाइल में डालना और julia file.jlउसी त्रुटि के माध्यम से इसे चलाना है ?
— kirbyfan64sos
मुझे लगता है कि यह मेरे जवाब के ऊपर गड़बड़ में पठनीय नहीं है। हां, मैंने एक .jl फ़ाइल के माध्यम से कंसोल और इसे शामिल करने की कोशिश की। "अगर मैं इसे एक .jl फ़ाइल के माध्यम से शामिल करता हूं तो यह आउटपुट बनाता है, लेकिन अगर मैं जूलिया REPL को वापस पाने के लिए एंटर दबाता हूं तो यह त्रुटि को फेंक देता है।" अगर मैं .jl फ़ाइल के माध्यम से आपके उदाहरण को चलाता हूं, तो प्रोग्राम कुछ इनपुट के लिए प्रतीक्षा करता है पहले julia> REPL / प्रॉम्प्ट वापस आता है।
— एमएल
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.