26

( इस चुनौती से प्रेरित होकर ।)

मान लीजिए कि हमारे पास एक स्ट्रिंग है ABBCBA। हम कह सकते हैं कि इस प्रकार , के बीच Aऔर वृद्धि है ; हम कह सकते हैं कि कुछ भी नहीं बदलने के लिए और के बीच एक रन है ; और अंत में हम कह सकते हैं कि बीच में गिरावट है और । हम इस तरह से एक ग्राफ खींच सकते हैं:BBABBCB

             A   B   B   C   B   A
Rising:        o       o
Continuing:        o
Falling:                   o   o

लेबल के बिना, और व्हाट्सएप को छोटा करना:

o o
 o
   oo

यह इनपुट के लिए अपेक्षित आउटपुट है ABBCBA।

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

o   o
  o 
      o o

इनपुट में कम से कम तीन अक्षर होंगे। स्ट्रिंग में पूरी तरह से अपरकेस अक्षर शामिल होंगे, लेकिन आप इसके बजाय लोअरकेस अक्षरों का उपयोग कर सकते हैं।

परीक्षण के मामलों

TEST CASE
LINE 1
LINE 2
LINE 3

HELLOWORLD
 o oo o
  o
o    o oo

TESTCASE
 oo  o

o  oo o

EXAMINATION
o o o o o

 o o o o o

ZSILENTYOUTH
  o ooo o

oo o   o oo

ABC
oo



ABCBA
oo

  oo

code-golf string ascii-art

— कोनोर ओ ब्रायन
स्रोत

क्या प्रत्येक लगातार os के बीच एक स्थान हो सकता है , या आउटपुट को कॉम्पैक्ट होना चाहिए?

— जुंगह्वान मिन सिप

@ जेएचएम ज़रूर, यह ठीक है।

— कॉनर ओ'ब्रायन

इसके अलावा, क्या आउटपुट को एक स्ट्रिंग होना चाहिए, या क्या इसे केवल उदाहरण के समान दिखने की आवश्यकता है?

— जंगहवान मिन सिप

@ जेएचएम आपके मन में क्या है?

— कॉनर ओ'ब्रायन

मेरे पास जो कोड है वह ग्रिड उत्पन्न करता है।

— जुंगवान मिन सिप

6

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

OIṠ“ o ”ṙZY

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

यह काम किस प्रकार करता है

OIṠ“ o ”ṙZY  Main link. Argument: s (string)

O            Ordinal; replace all characters with their code points.
 I           Increments; compute the differences of consecutive code points.
  Ṡ          Sign function.
   “ o ”ṙ    Rotate that string -1, 0, or 1 unit(s) to the left.
         Z   Zip; transpose rows and columns.
          Y  Join, separating by linefeeds.

— डेनिस
स्रोत

11

गणितज्ञ, 93 83 68 64 बाइट्स

(उपयोग करता है 0, नहीं O)

Row[Column@Insert[{,},0,2-#]&/@Sign@Differences@LetterNumber@#]&

व्याख्या

LetterNumber@#

इनपुट के प्रत्येक वर्ण की वर्णमाला में स्थान प्राप्त करता है।

Sign@Differences@

प्रत्येक लगातार तत्वों के बीच अंतर लेता है, और संकेत लेता है ( -1नकारात्मक / गिरने के लिए, 00 / जारी रखने के लिए, 1सकारात्मक / वृद्धि के लिए)

Insert[{,},0,2-#]&

0दो Nullएस की सूची में एक सम्मिलित करता है , पहली स्थिति में अगर ऊपर उठता है, तो यदि जारी रहता है, और गिरने पर तीसरा स्थान।

Row[Column@ ... ]

आउटपुट तैयार करता है।

यदि आउटपुट प्रश्न में एक से अलग दिख सकता है, तो उपरोक्त कोड को 41 बाइट्स तक छोटा किया जा सकता है:

ListPlot@*Sign@*Differences@*LetterNumber

... जो कुछ इस तरह बनाता है ("ABBCBA" के लिए):

— जंगहवान मिन
स्रोत

41 बाइट कैसे दिखती है?

— कॉनर ओ'ब्रायन

@ ConorO'Brien कृपया संपादन देखें।

— जुंगवान मिन

10

MATL , 15 , 14 बाइट्स

dZSqtQtQv~79*c

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

स्पष्टीकरण:

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

तो सबसे पहले, हम कहते हैं dZS। dहमें प्रत्येक लगातार तत्व के बीच अंतर देता है, और ZSहमें प्रत्येक तत्व का संकेत (-1, 0, या 1) देता है। तो इनपुट के रूप में 'HELLOWORLD' के साथ, पहले चरण के बाद हम करेंगे:

-1  1  0  1  1 -1  1 -1 -1

अब, हम केवल qइसे बढ़ाने और पाने के लिए उपयोग करते हैं:

-2  0 -1  0  0 -2  0 -2 -2

और फिर दो बार हम स्टैक के शीर्ष को दोहराते हैं और सरणी को बढ़ाते हैं ( tQ) इसके बाद हमारे पास होगा

-2  0 -1  0  0 -2  0 -2 -2
-1  1  0  1  1 -1  1 -1 -1
0   2  1  2  2  0  2  0  0

अब सभी '0' हैं जहाँ हम एक चरित्र को आउटपुट करना चाहते हैं। तो, हम इन तीन सरणियों को एक मैट्रिक्स ( v) में शामिल करते हैं , और तार्किक रूप से इसे नकारते हैं ( ~)। फिर हम मैट्रिक्स के प्रत्येक मान को 'O', ( 79*) के ASCII मान से गुणा करते हैं और इसे स्ट्रिंग के रूप में प्रदर्शित करते हैं c।

— DJMcMayhem
स्रोत

एक बार जब आपके पास वेक्टर [-1, 1, 0, 1, ...] होता है, तो आप उन्हें कॉलम सूचकांकों [1,2,3,4, ...] के साथ विरल मैट्रिक्स की पंक्ति सूचकांकों के रूप में उपयोग कर सकते हैं। इसे पूर्ण मैट्रिक्स में बदलें।

— निक अल्जर

ठीक है कोई बात नहीं, उस सुझाव की कोशिश की, कुछ भी बचाने के लिए प्रतीत नहीं होता है

— Nick Alger

@NickAlger वैसे भी टिप के लिए धन्यवाद! जिज्ञासा से बाहर, क्या मैं देख सकता था कि तुम क्या लेकर आए हो?

— DJMcMayhem

ज़रूर। निम्नलिखित 19 वर्ण है, हालांकि यह शायद कुछ बेहतर किया जा सकता है, dZS2 + tn: tn-XPg79 * c

— निक अल्जर

एक युगल अनुकूलन के साथ इसे 16 पर पाएं, dZSqq_tn: lZ; 79 * c

— निक अल्जीरिया

8

हास्केल, 63 बाइट्स

f w=[do(e,y)<-zip w$tail w;max" "['o'|b e y]|b<-[(<),(==),(>)]]

आउटपुट की पंक्तियों का प्रतिनिधित्व करते हुए, तीन तारों की सूची लौटाता है। कोई अचेतन संदेश शामिल हैं।

डायने ने doनोटेशन का उपयोग करके तीन बाइट्स को बचाया और maxइसके बजाय एक सूची समझ और last।

— लिन
स्रोत

3

महान, इसमें कोई अचेतन संदेश नहीं है! वो क्या है?

— कॉनर ओ'ब्रायन

5

['o'|b e y]..

— izabera

हां, मेरे गुरु रुको क्या हो रहा है?

— कैलक्यूलेटरफलाइन

7

CJam , 19 बाइट्स

l2ew{:-g)S3*0t}%zN*

के 0बजाय का उपयोग करता है o।

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

व्याख्या

l      e# Read input.
2ew    e# Get all pairs of consecutive letters.
{      e# Map this block over the pairs...
  :-   e#   Compute the difference between the two letters.
  g    e#   Signum. Gives -1 for rises, 1 for falls, 0 otherwise.
  )    e#   Increment. Gives 0 for rises, 2 for falls, 1 otherwise. Call this i.
  S3*  e#   Push a string with three spaces.
  0t   e#   Replace the i'th space (zero-based) with a zero.
}%
z      e# Transpose.
N*     e# Join with linefeeds.

— मार्टिन एंडर
स्रोत

6

पायथन 2, 76 71 बाइट्स

lambda s:[''.join(' o'[cmp(*x)==n]for x in zip(s,s[1:]))for n in-1,0,1]

@Xnor के लिए धन्यवाद मुझे सूचित करने के लिए कि स्ट्रिंग्स की सूची वापस करने की अनुमति है।

Ideone पर इसका परीक्षण करें ।

— डेनिस
स्रोत

आपको तीन स्ट्रिंग्स की सूची तैयार करने की अनुमति है, जो आपको ए lambda।

— xnor

मैं हूँ? वह सब कुछ बदल देता है।

— डेनिस

मैंने टिप्पणियों में पूछा क्योंकि लिन का हास्केल जवाब यह कर रहा था।

— xnor

6

जावास्क्रिप्ट (ईएस 6), 96 95 89 87 82 बाइट्स

2 बाइट्स का उपयोग करके बचाया 0बजाय oके रूप में कोनोर ओ ब्रायन ने सुझाव दिया,
2 6 बाइट्स ETHproductions करने के लिए धन्यवाद बचाया

let f =

s=>[1,0,-1].map(k=>s.replace(/./g,(c,i)=>i--?(c>s[i])-(c<s[i])-k&&' ':'')).join`
`

console.log(f("HELLOWORLD"));
console.log(f("EXAMINATION"));

स्निपेट का विस्तार करें

— Arnauld
स्रोत

1

जब से तुम किसी भी चरित्र का उपयोग कर सकते हैं, की जगह है 'o'के साथ 0मदद के किसी भी?

— कॉनर ओ'ब्रायन

@ ConorO'Brien - वास्तव में, यह करता है। ;)

— अरनुलड

1

मुझे लगता है s=>[1,0,-1].map(k=>[...s].map(c=>(r=p?(c>p)-(c<p)-k&&' ':'',p=c,r),p=0).join``).join`\n` कि काम करेगा, 2 बाइट्स की बचत होगी।

— ETHproductions

आप मैन्युअल रूप से ट्रैक रखने के बजाय प्रत्येक बार पिछले चरित्र को हथियाने के द्वारा एक और बाइट बचा सकते हैं s=>[1,0,-1].map(k=>[...s].map((c,i)=>(p=s[i-1])?(c>p)-(c<p)-k&&' ':'').join``).join`\n` :। s.replaceआपको कई बाइट्स भी बचाएगा [...s].map().join()।

— ETHproductions

4

पर्ल, 47 बाइट्स

के लिए +1 शामिल है -p

STDIN पर इनपुट दें:

bumpy.pl <<< ABBCBA

bumpy.pl:

#!/usr/bin/perl -p
$_ x=3;s%.%/\G(.)(.)/?$2cmp$1^$.&&$":--$.>0%eg

— टन हास्पेल
स्रोत

4

MATL, 16 14 बाइट्स

dZSqq_tn:79Z?c

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

यह डीजेएमसीमहेम के उत्तर की चर्चा से बढ़ गया । भले ही यह उत्तर ~~2 वर्णों~~ की समान लंबाई का हो, लेकिन विधि कुछ भिन्न है इसलिए यह स्वतंत्र हित की हो सकती है।

2 बाइट बचाने के सुझाव के लिए लुइस मेंडो का धन्यवाद (टिप्पणियां देखें)

स्पष्टीकरण:

'dZS' को एक वेक्टर मिलता है जहां प्रत्येक प्रविष्टि सक्सेजिव वर्णों के बीच अंतर का संकेत है, फिर 'qq_' प्रत्येक प्रविष्टि को दो से घटाता है और संकेत को फ़्लिप करता है, इसलिए अब यदि वर्ण बढ़ता है तो यह 1 है, यदि यह समान 2 रहता है, और अगर यह घटता है 3. उदाहरण के लिए,

dZSqq_ applied to 'HELLOWORLD' creates the vector [3 1 2 1 1 3 1 3 3]

इसके बाद, 't' स्टैक पर पिछले वेक्टर की एक कॉपी बनाता है, फिर 'n:' वेक्टर को [1,2,3,4, ...] स्टैक पर रखता है। तब '79' स्टैक पर मूल्य 79 रखता है। मूल्य 79 को चुना गया है क्योंकि यह यूनिकोड चरित्र 'ओ' के लिए नंबर है, जो बाद में हमारा आउटपुट होगा। (मूल्य के बजाय 79 को बाद में रखने के विचार के लिए लुइस मेंडो के लिए धन्यवाद)

tn:79 applied to [3 1 2 1 1 3 1 3 3] creates the following items:
[3 1 2 1 1 3 1 3 3]   <-- first item on the stack
[1 2 3 4 5 6 7 8 9]   <-- second item on the stack
79                    <-- third item on the stack

इस बिंदु पर हमारे पास पंक्ति सूचकांकों, स्तंभ सूचकांकों और एक विरल मैट्रिक्स के गैर-अक्षीय मूल्य हैं जो कि आउटपुट वर्ण चाहते हैं, और जहां भी हम व्हाट्सएप का उत्पादन करना चाहते हैं, उसका मूल्य 79 है। हम स्टैक से इन तीन वस्तुओं को लेते हैं और इस विरल मैट्रिक्स को MATL के विरल मैट्रिक्स कमांड 'Z?' के साथ बनाते हैं। अर्थात्,

dZSqq_tn:79 Z? applied to 'HELLOWORLD' outputs the following:
[0  79 0  79 79 0  79 0  0 ]
[0  0  79 0  0  0  0  0  0 ]   <-- 3-by-n sparse matrix
[79 0  0  0  0  79 0  79 79]

जो कुछ बचा है, वह मैट्रिक्स को संख्याओं से यूनिकोड वर्णों में बदलना है, जो कमांड 'c' द्वारा किया जाता है। 79 का 'ओ' बन गया, और 0 का स्पेस बन गया:

dZSqq_tn:79Z?c applied to 'HELLOWORLD' outputs:
[  o   o o   o    ]
[    o            ]   <-- 3-by-n sparse matrix of characters.
[o         o   o o]

इसके बाद वर्णों के मैट्रिक्स को अंतर्निहित रूप से प्रदर्शित किया जाता है।

— निक अल्जर
स्रोत

आप सीधे स्पार्स मैट्रिक्स के लिए गैर-अक्षीय मान के रूप में 79 का उपयोग कर सकते हैं, इस प्रकार दो बाइट्स बचा सकते हैं। इसके अलावा, मुझे लगता है कि यह पहली बार है कि विरल मैट्रिस का उपयोग MATL उत्तर में किया जाता है :-)

— लुइस

@LuisMendo धन्यवाद! मैंने आपके द्वारा सुझाए गए परिवर्तन को संपादित करने के लिए पोस्ट को संपादित किया

— निक अल्जीर

3

PHP, 95 बाइट्स

for($b[1]=$b[0]=$b[-1]=" ";($s=$argv[1])[++$i];)$b[$s[$i-1]<=>$s[$i]][$i]=8;echo join("\n",$b);

1. इंडेक्स -1 से 1 विकल्प के साथ तार की एक सरणी बनाएं $b=array_fill(-1,3," ");

2. रिक्त स्थान ऑपरेटर और इनपुट की स्थिति से निर्भर तार भरें

3. स्वचालित रूप से एक नई लाइन के साथ सरणी में शामिल हों

पहला रास्ता 111 बाइट्स

for($o=" ";$i<$l=strlen($s=$argv[1])-1;)$o[$l*(1+($s[$i]<=>$s[$i+1]))+$i++]=8;echo join("\n",str_split($o,$l));

स्पेसशिप ऑपरेटर स्पेसशिप ऑपरेटर का उपयोग करें<=>

— जार्ग हुल्सरमन
स्रोत

1

यदि आप लैटिन -1 में अपने कार्यक्रम को सांकेतिक शब्दों में बदलना , के ~õलिए एक आसान शॉर्टकट है "\n"। नहीं, सचमुच में!

— लिन

1

के लिए एक ही बात है " ", जो हो सकता है ~ß। उदाहरण। आप इन्हें देखते समय अपने ब्राउज़र को लैटिन -1 में एन्कोडिंग सेट करना चाहते हैं ।

— लिन

@ लियन या ~ ³ ~ † ~ '~' विचार के लिए धन्यवाद। मैं यूनिकोड पसंद करूंगा

— Jörg Hülsermann

2

जावास्क्रिप्ट (ईएस 6), 81 बाइट्स

s=>[s,s,s].map(f=([c,...s],n)=>(p=s[0])?((c<p)-(c>p)+n-1&&" ")+f(s,n):"").join`
`

खरोंच से लिखा गया है, हालांकि यह @ अरनुल्द के जवाब से काफी प्रेरित था । प्रत्येक पंक्ति की सामग्री की गणना करने के लिए पुनरावर्तन का उपयोग करता है।

— ETHproductions
स्रोत

2

रूबी, 66 64 बाइट्स

->s{(-1..1).map{|n|s.gsub(/.(?=(.))/){"o  "[n+($1<=>$&)]}.chop}}

इसे eval.in: https://eval.in/649503 पर देखें

— जॉर्डन
स्रोत

2

जावा 7, 158 156 बाइट्स

String c(char[]z){String a,b,c=a=b="";for(char i=1,q=z[0],o=79,s=32,x;i<z.length;a+=(x=z[i])>q?o:s,b+=x==q?o:s,c+=x<q?o:s,q=z[i++]);return a+"\n"+b+"\n"+c;}

2 बाइट्स @Frozn की बदौलत बच गए ।

अनगढ़ और परीक्षण के मामले:

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

class M{
  static String c(char[] z){
    String a,
           b,
           c = a = b = "";
    for(char i = 1,
             q = z[0],
             o = 79,
             s = 32,
             x; i < z.length; a += (x = z[i]) > q
                                     ? o
                                     : s,
                              b += x == q
                                     ? o
                                     : s,
                              c += x < q
                                     ? o
                                     : s,
                              q = z[i++]);
    return a + "\n" + b + "\n" + c;
  }

  public static void main(String[] a){
    print("HELLOWORLD");
    print("TESTCASE");
    print("EXAMINATION");
    print("ZSILENTYOUTH");
    print("ABC");
    print("ABCBA");
    print("ABBCBA");
    print("UVVWVVUVVWVVUVVW");
  }

  static void print(String s){
    System.out.println(c(s.toCharArray()));
    System.out.println("-------------------------");
  }
}

आउटपुट:

 O OO O  
  O      
O    O OO
-------------------------
 OO  O 

O  OO O
-------------------------
O O O O O 

 O O O O O
-------------------------
  O OOO O  

OO O   O OO
-------------------------
OO


-------------------------
OO  

  OO
-------------------------
O O  
 O   
   OO
-------------------------
O O   O O   O O
 O  O  O  O  O 
   O O   O O   
-------------------------

— केविन क्रूज़सेन
स्रोत

1

मुझे यकीन नहीं है कि यह काम करता है लेकिन a,b,c=b=a=""कम होगा।

— फ्रोजन

@Frozn धन्यवाद, संपादित। यह वास्तव में काम करता है। पुनश्च: आप इसे फोर्क करके खुद को विचारधारा में जाँच सकते थे। ;)

— केविन क्रूज़सेन

आप सही हे! मैं हमेशा लिंक को देख रहा हूं और केवल उसी के लिए ग्रहण शुरू कर रहा हूं वह इसके लायक नहीं है :)

— Frozn

2

क्लोरा (20 बाइट्स)

<IN?o ;=IN?o ;>IN?o

स्पष्टीकरण:

3 क्लोरा प्रोग्राम हैं, प्रत्येक आउटपुट लाइन के लिए एक।

पहला कार्यक्रम, `<IN?o`

जांचें कि क्या वर्तमान इनपुट चार्ट अगले चार से Iछोटा <है N। परिणाम को वैश्विक ध्वज में सहेजें। ध्वज परिणाम की जाँच करें ?और यदि सही है, तो आउटपुट o, रिक्त स्थान (हाँ, वहाँ रिक्त स्थान है)।

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

आप इसे स्वयं द्वारा परीक्षण कर सकते हैं, जिसमें clora.js भी शामिल हैं और इसे निष्पादित कर रहे हैं

(function() {
  var x = new Clora('<IN?o ;=IN?o ;>IN?o ');
  x.execute('EXAMINATION', function(r) {
    console.log(r)
  })
})();

— OPSXCQ
स्रोत

यह कड़ाई से गैर-प्रतिस्पर्धी लगता है, क्योंकि यह इस चुनौती के बाद बनाया गया था। हालांकि यह एक दिलचस्प लंगोट जैसा दिखता है!

— कॉनर ओ'ब्रायन

1

पायथ, 21 बाइट्स

jCmX*3\ h._d0-M.:CMz2

एक प्रोग्राम जो एसटीडीआईएन पर एक अयोग्य स्ट्रिंग का इनपुट लेता है और परिणाम प्रिंट करता है।

यह @ मार्टिनएंडर के सीजाम उत्तर के समान विचार का उपयोग करता है ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

यह काम किस प्रकार करता है

jCmX*3\ h._d0-M.:CMz2  Program. Input: z
                 CMz   Map ordinal over z, yielding the code-points of the characters
               .:   2  Yield all length-2 sublists of that
             -M        Map subtraction over that
  m                    Map the following over that with variable d:
         ._d            Yield the sign of d
        h               Increment that (i)
    *3\                 Yield string literal of 3 spaces, "   "
   X        0           Replace the space at index i with 0
 C                     Transpose that
j                      Join that on newlines
                       Implicitly print

— TheBikingViking
स्रोत

1

PHP 7, 81 80 77 बाइट्स

नोट: Windows-1252 एन्कोडिंग का उपयोग करता है

for($x=2;~$x--;print~õ)for($a=$argn;$c=$a[$$x+1];)echo$c<=>$a[$$x++]^$x?~ß:o;

इस तरह से चलाएं:

echo HELLOWORLD | php -nR 'for($x=2;~$x--;print"\n")for($a=$argn;$c=$a[$$x+1];)echo$c<=>$a[$$x++]^$x?" ":o;';echo

व्याख्या

लाइनों पर दोहराता (गिने 1, 0, -1)। फिर हर लाइन के लिए इनपुट स्ट्रिंग पर पुनरावृत्त करता है। जब अंतरिक्ष यान तुलना का परिणाम लाइन संख्या के बराबर होता है, तो आउटपुट o, अन्यथा, एक स्थान का उत्पादन करता है। हर लाइन के बाद, एक नई लाइन प्रिंट करें।

बदलाव

जब $xहै -1, जो हम द्विआधारी नकार (परिणाम 0) द्वारा पा सकते हैं पुनरावृति बंद करो । एक बाइट को जोड़ने की तुलना में बचाता है 1(या पूर्व-वृद्धि के साथ 2)।
का उपयोग करके 3 बाइट्स सहेजे गए $argn

— aross
स्रोत

1

आप -d error_reporting=30709अपनी बाइट गिनती में जोड़ना भूल गए ।

— टाइटस

@ दुनिया में क्यों मुझे बाइट की गिनती में जोड़ना होगा? यह केवल इतना है कि PHP नोटिस (जो कि आग्नेय हैं) मुद्रित नहीं हैं!

— 31 बजे

भी जोड़ सकता है 2>/dev/null, लेकिन वह सभी त्रुटियों से छुटकारा पा लेगा, जिसमें घातक है

— सकल

ओह, और एक संदर्भ

— 7

कुछ इस तरह If you get warnings, set the default value with ...। प्लीज मेरी पैंटी को बहाना; मैंने उस मूल्य को डिकोड नहीं किया।

— टाइटस

0

Lua ~~326~~ 303 बाइट्स tl = 0 s = io.read () o1, o2, o3 = "", "", "" t = {} के लिए i = 1, # s do t [i] = उप: (i) , i) tl = tl + 1 अंत v = 1, tl-1 करते हैं यदि t [v] t [v + 1] तो o1 = o1 .. "" o2 = o2 .. "" o3 = o3 .. " o "अंतिम छोर प्रिंट (o1 .." \ n ".. o2 .." \ n ".. o3)

एक अनप्लग्ड संस्करण

tl = 0 --set the tables length to 0
s = io.read() --Get the string from input
o1,o2,o3="","","" --Set the 3 output rows to empty strings
t = {} --Make a table for the string to be sent into
for i = 1, #s do --Loop from 1 to the length of the string
    t[i] = s:sub(i, i) --Set the I-th term in the table to the I-th character in the string
    tl = tl+1 --Add 1 to the table length
end --End the loop
for v=1,tl-1, 1 do --Loop from 1 to the tables length - 1, incrementing by 1
    if t[v] < t[v+1] then --Lua supports greater than less than and equals to with charactes, so this if statement detects if the string is rising
        o1=o1.."o" --Adds an o to the end of the first line of output
        o2=o2.." " --Adds a space to the second line
        o3=o3.." " --Adds a space to the third line
    elseif t[v] == t[v+1] then --Detects if the string is continuing
        o1=o1.." " --Adds a space to the first line
        o2=o2.."o" --Adds an o to the second line
        o3=o3.." " --Adds a space to the third line
    elseif t[v] > t[v+1] then --Detects if string is falling
        o1=o1.." " --Adds a space to the first line
        o2=o2.." " --Adds a space to the second line
        o3=o3.."o" --Adds an o to the third line
    end --Ends the if statement
end --Ends the loop
print(o1.."\n"..o2.."\n"..o3) --Prints the output

— एलेक्स एलन
स्रोत

मुझे लगता है कि आप कुछ व्हाट्सएप से बाहर निकल सकते हैं, कह सकते हैं t1 = 0? को t1=0? और ऐसी ही जगहें।

— कॉनर ओ'ब्रायन

मैं अब ठीक करूँगा

— एलेक्स एलन

0

आर, 114 बाइट्स

एक गैर-प्रतिस्पर्धात्मक आर उत्तर।

v=y=z=rep(" ",length(x<-diff(utf8ToInt(scan(,"")))));v[x>0]="#";y[x==0]="#";z[x<0]="#";cat(v,"\n",y,"\n",z,sep="")

व्याख्या

कमांड लाइन से इनपुट पढ़ें और एएससीआई दशमलव वेक्टर में परिवर्तित करें
1 अंतर लें और सफेद रिक्त स्थान के साथ एक ही लंबाई के 3x वैक्टर बनाएं
#यदि अंतर हैं >0, ==0या फिर सफेद अंतरिक्ष वैक्टर को बदलें <0।
वैक्टर को कुरेदें और उन्हें अलग-अलग स्थानों पर प्रिंट करें

— Billywob
स्रोत

क्यों नॉनकंपेटिंग?

— कॉनर ओ'ब्रायन

@ ConorO'Brien मुझे लगता है कि यह अन्य आर उत्तरों के खिलाफ प्रतिस्पर्धा कर रहा है, लेकिन मूल समाधान लंबे समय तक और सामान्य रूप से दिलचस्प होने के लिए अद्वितीय नहीं था।

— बिलीवॉब

एक ऊबड़ स्ट्रिंग ड्रा

परीक्षण के मामलों

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

यह काम किस प्रकार करता है

गणितज्ञ, 93 83 68 64 बाइट्स

व्याख्या

MATL , 15 , 14 बाइट्स

हास्केल, 63 बाइट्स

CJam , 19 बाइट्स

व्याख्या

पायथन 2, 76 71 बाइट्स

जावास्क्रिप्ट (ईएस 6), 96 95 89 87 82 बाइट्स

पर्ल, 47 बाइट्स

MATL, 16 14 बाइट्स

PHP, 95 बाइट्स

जावास्क्रिप्ट (ईएस 6), 81 बाइट्स

रूबी, 66 64 बाइट्स

जावा 7, 158 156 बाइट्स

क्लोरा (20 बाइट्स)

पहला कार्यक्रम, <IN?o

पायथ, 21 बाइट्स

PHP 7, 81 80 77 बाइट्स

व्याख्या

बदलाव

आर, 114 बाइट्स

व्याख्या

पहला कार्यक्रम, `<IN?o`