47

स्किटल्स रंगीन कैंडी हैं जहां 5 अलग-अलग स्वाद हैं; अंगूर, हरा सेब, नींबू, नारंगी, और स्ट्रॉबेरी (पी) मूत्र, (जी) रेने, (वाई) एलो, (ओ) रेंज, और (आर) एड द्वारा क्रमशः दर्शाया गया है। मैं सभी अलग-अलग रंगों को छाँटकर स्किटल्स खाता था, फिर उन्हें क्रम से खाता था। कार्यालय में कुछ अजीब लगने के बाद, मैं अब उन्हें एक सामान्य व्यक्ति की तरह खाने का नाटक करता हूं। आपका कार्य इस का अनुकरण करना है:

आपके कोड (पूर्ण प्रोग्राम या फ़ंक्शन) को इनपुट (किसी भी उचित प्रारूप में) के रूप में स्कीटल्स (10x10) की एक सरणी प्राप्त होगी। यह सरणी अनसुनी स्किटल्स के ढेर का प्रतिनिधित्व करेगी। अपने काम के लिए उन्हें कम से कम पसंदीदा रंग से "खाने" है। मेरा पसंदीदा ऑर्डर अंगूर, हरा सेब, नींबू, नारंगी, स्ट्रॉबेरी है, लेकिन आप किसी भी ऑर्डर को चुनने के लिए स्वतंत्र हैं क्योंकि यह लगातार लागू होता है (कृपया अपनी प्रविष्टि में अपनी वरीयता सूचीबद्ध करें ताकि मैं आपको इसके लिए जज कर सकूं)। कैंडी के प्रत्येक टुकड़े को खाने के बाद आपका कोड आउटपुट होगा (उसी प्रारूप में आप इनपुट लेते हैं) बचे हुए ढेर को एक स्थान से खाए गए टुकड़े के साथ। आप तब तक दोहराएंगे जब तक कि आपका पसंदीदा अवशेष न हो। आप खाने के लिए किसी भी पतले का चयन कर सकते हैं (यादृच्छिक या निर्धारक हो सकता है)। ट्रेलिंग रिक्त स्थान रखे जाने चाहिए।

उदाहरण के लिए, आपका आउटपुट अनुक्रम इस तरह दिख सकता है (संक्षिप्तता के लिए 5x5 का उपयोग करके और रिक्त स्थान दिखाते हुए .)

start   1     2     3     4     5        n 
.org. .org. .org. .org. .or.. .or..    ..r..
prgrg .rgrg .rgrg .rgrg .rgrg .r.rg    .r.r.
gggpr gggpr ggg.r ggg.r ggg.r ggg.r    ....r
oyyor oyyor oyyor oyyor oyyor oyyor    ....r
.r.p. .r.p. .r.p. .r... .r... .r...    .r...

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा कोड है

टीएल; डीआर नियम:

सबमिशन पूरा प्रोग्राम या फंक्शन हो सकता है
इनपुट को किसी भी उचित विधि (एसटीडीआईएन, फ़ंक्शन तर्क, आदि) द्वारा किसी भी उचित प्रारूप (स्ट्रिंग, सूची, मैट्रिक्स, आदि) में लिया जा सकता है। हालाँकि पंक्तियों के बीच कुछ परिसीमन होना चाहिए
आउटपुट को किसी भी उचित विधि द्वारा इनपुट के रूप में एक ही प्रारूप में उत्पादित किया जाना चाहिए (STDOUT, function return, ect।)। मध्यवर्ती उत्पादन को सीमांकित किया जा सकता है या नहीं किया जा सकता है
पहला आउटपुट पहला इनपुट होगा
ट्रेलिंग रिक्त स्थान को संरक्षित किया जाना चाहिए
किसी भी रंग क्रम का उपयोग किया जा सकता है (आपके उत्तर में सूची)
वर्तमान रंग के किसी भी स्किथ को खाया जा सकता है
अंतिम आउटपुट केवल आपका पसंदीदा रंग और स्थान होगा
यदि संभव हो, तो अपने सबमिशन का परीक्षण करने के लिए एक ऑनलाइन कंपाइलर का लिंक शामिल करें

code-golf

— wnnmaw
स्रोत

4

@ मुकुलकुमार, सही है, आप चाहते हैं कि आप उनके साथ बेहतर

— रहें

2

क्या हम स्कील को 100-स्किटल स्ट्रिंग के रूप में स्वीकार कर सकते हैं, कोई रेखा नहीं टूटती है या कुछ भी?

— गेब्रियल बेनामी

1

क्या मध्यवर्ती आउटपुट को कुछ भी अलग करने की आवश्यकता है?

— प्रहार

5

संबंधित कोडगॉल्फ.स्टैकएक्सचेंज.com

— डिजिटल ट्रॉमा

8

मैंने इस चुनौती में प्रवेश करने पर विचार किया, और फिर पढ़ा " कृपया अपनी अधीनता में अपनी वरीयता सूचीबद्ध करें ताकि मैं आपको इसके लिए न्याय कर सकूं "। मुझे लगता है कि लोग मेरी प्राथमिकताओं के बारे में पहले से ही निर्णय ले चुके हैं!

— टोबे स्पाइट

16

जेली , 16 14 13 बाइट्स

Ṅ⁶ỤṪ$¦µQL>3µ¿

TryItOnline!

सबसे कम से कम पसंदीदा, जैसा कि उनके ओसीडी के बारे में गंभीर किसी के लिए, वर्णमाला है!

पाठ के रूप में इनपुट और आउटपुट लेता है (यानी नई पंक्तियों द्वारा पंक्तियों को सीमांकित किया जाता है)।

3 बाइट्स ने दिशा को उल्टा करके और एक अलग विधि का उपयोग करके बचाया: वर्णमाला से वर्ण खोजने के बजाय ग्रेड।

कैसे?

Ṅ⁶ỤṪ$¦µQL>3µ¿ - Main link: Skittle text
      µ    µ  - monadic chain separation
            ¿ - while
       Q      - unique items
        L     - length
         >3   - greater than 3 (until only new lines, spaces and 'g's remain)
Ṅ             -     print z and a line feed, yield z
    $         -     treat last two links as a monad
  Ụ           -         grade up (get indices of: new lines; spaces; gs; os; ps; rs; ys)
   Ṫ          -         tail (the last of those, so last y if there is one, else last r, ...)
 ⁶            -     space character
     ¦        -     apply at index (replace that index with a space)

— जोनाथन एलन
स्रोत

8

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

चुनौती में वर्णित फ्लेवर का आदेश दिया गया है: अंगूर, हरे सेब, नींबू, नारंगी, स्ट्रॉबेरी।

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

f=(s,n=3,r=s)=>(S=s.replace('oygp'[n],' '))!=s&&(r+=`
`+S)||n--?f(S,n,r):r

परीक्षण का मामला

यह परीक्षण मामला 5x5 उदाहरण का उपयोग कर रहा है। किसी अन्य ग्रिड का आकार अपेक्षित रूप से काम करना चाहिए।

कोड स्निपेट दिखाएं

f=(s,n=3,r=s)=>(S=s.replace('oygp'[n],' '))!=s&&(r+=`
`+S)||n--?f(S,n,r):r

console.log(f(
` org 
prgrg
gggpr
oyyor
 r p 
`))

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

— Arnauld
स्रोत

8

दे घुमा के, 48, 46 बाइट्स

अपडेट करें:

प्रिंट करने के लिए कच्चे मापदंडों का उपयोग करके दो बाइट्स को बचाया;

golfed

sed -nz "p;:a;`printf "s/%s/ /p;ta;" p g y o`"

स्टड पर इनपुट लेता है, स्टडआउट पर प्रिंट करता है। बैंगनी, हरा, पीला और फिर नारंगी खाती है।

एक बराबर sed कार्यक्रम होगा:

p;:a;s/p/ /p;ta;s/g/ /p;ta;s/y/ /p;ta;s/o/ /p;ta

नमूना उत्पादन (सीमांकक केवल स्पष्टता के लिए हैं)

-----
 org 
prgrg
gggpr
oyyor
 r p 
-----
-----
 org 
 rgrg
gggpr
oyyor
 r p 
-----
-----
 org 
 rgrg
ggg r
oyyor
 r p 
-----
-----
 org 
 rgrg
ggg r
oyyor
 r   
-----
-----
 or  
 rgrg
ggg r
oyyor
 r   
-----
-----
 or  
 r rg
ggg r
oyyor
 r   
-----
-----
 or  
 r r 
ggg r
oyyor
 r   
-----
-----
 or  
 r r 
 gg r
oyyor
 r   
-----
-----
 or  
 r r 
  g r
oyyor
 r   
-----
-----
 or  
 r r 
    r
oyyor
 r   
-----
-----
 or  
 r r 
    r
o yor
 r   
-----
-----
 or  
 r r 
    r
o  or
 r   
-----
-----
  r  
 r r 
    r
o  or
 r   
-----
-----
  r  
 r r 
    r
   or
 r   
-----
-----
  r  
 r r 
    r
    r
 r   
-----

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

— टसेपेल्लिन
स्रोत

7

पायथन 2, 60 57 56 बाइट्स

def f(s):print s;q=max(s);q>'g'and f(s.replace(q,' ',1))

repl.it

रिकर्सिव फ़ंक्शन जो रिवर्स अल्फाबेटिकल ऑर्डर में खाता है, आखिरी के लिए ग्रीन्स को छोड़कर।

इनपुट sएक पंक्ति सीमांकक के साथ एक स्ट्रिंग है जिसमें एक अध्यादेश कम से कम है 'g'(उदाहरण के लिए एक नई पंक्ति या अल्पविराम)।

फ़ंक्शन इसके इनपुट को प्रिंट करता है, और उसके बाद पुन: पता लगाता है कि उस इनपुट में 'g' से अधिक कुछ भी है या नहीं, किसी स्थान द्वारा प्रतिस्थापित अधिकतम वर्ण की पहली घटना के साथ इनपुट को पास करना।

(लगभग मेरे जेली उत्तर का एक बंदरगाह ।)

— जोनाथन एलन
स्रोत

6

पर्ल, 53 46 + 2 = 48 बाइट्स

साथ दौड़ो -0n

-10 बाइट्स थैंक्स टू @ दादा

संपादित करें: यह इंगित करने के लिए @ दादा के लिए भी धन्यवाद, मैं पहले आउटपुट के रूप में इनपुट प्रिंट करना भूल गया। यह तय हो गया है।

say;eval sprintf"say while s/%s/./;"x4,p,o,g,r

इस उत्तर में थोड़ी सी चालाकी शामिल है, इसलिए मैं तोड़ दूंगा कि क्या हो रहा है।

सबसे पहले, पर्ल बहु-पंक्ति मापदंडों को पारित करना पसंद नहीं करता है। चर $/इनपुट रिकॉर्ड विभाजक है, और जब भी कोई इनपुट इसमें संग्रहीत चरित्र का सामना करता है, दुभाषिया उस इनपुट को समाप्त करता है और एक नया इनपुट शुरू करता है। डिफ़ॉल्ट सामग्री न्यूलाइन वर्ण है \n, जिसका अर्थ है कि मल्टी-लाइन स्ट्रिंग पास करना संभव नहीं है। ऐसा करने के लिए, हमें $/इसकी सामग्री से परेशान होना चाहिए । यह वह जगह है जहां -0झंडा आता है: सेटिंग चर में -0संग्रहित करेगी , दुभाषिया को एक ही बार में निहित चर में सब कुछ पढ़ने की अनुमति देता है ।null$/$_

चालबाजी का अगला evalबयान है। बस हम वास्तव में क्या कर रहे evalहैं? हम कथन evalके परिणाम को प्राप्त कर रहे हैं sprintf, जो नीचे दिया गया है:

sprintfपारित होने वाली पहली चीज स्ट्रिंग "say while s/%s/./;"को 4 बार दोहराया जाता है, इसलिए:

say while s/%s/./;say while s/%s/./;say while s/%s/./;say while s/%s/./;

फिर, sprintfचार नंगे वर्णों को पारित किया जाता है p,o,g,r, जो कि sprintfप्रत्येक उदाहरण को प्रतिस्थापित करते हुए, कथन में प्रक्षेपित होते हैं %s। फिर हमें जो मिलता है वह निम्न स्ट्रिंग है, जिसे evalफ़ंक्शन में पास किया जाता है:

say while s/p/./;say while s/o/./;say while s/g/./;say while s/r/./;

प्रत्येक whileलूप अभिव्यक्ति का मूल्यांकन करता है s/[color]/./, जो किसी भी रंग के पहले उदाहरण को $_एक अवधि के साथ निहित चर में बदल देता है । यदि एक प्रतिस्थापन किया जाता है, तो यह वापस आ जाता है 1, अन्यथा यह कुछ भी नहीं देता है। चूंकि s///इसके साइड-इफेक्ट्स हैं, यह मूल चर को संशोधित करता है $_, जिसकी सामग्री तब मुद्रित होती है say। इस लूप के चार संस्करण किए जाते हैं, जिसमें केवल येल्लो छोड़ते हुए शुद्धता, संतरे, साग और फिर लाल रंग की जगह होती है।

कारण यह है कि yयेल्लो बचे हैं क्योंकि नंगे नहीं हो सकते हैं, क्योंकि यह वास्तव में एक फ़ंक्शन है, और yउनमें से किसी भी पत्र के बजाय एक त्रुटि होगी। मैं इसे (+2 बाइट्स) के आसपास उद्धरण डालकर या एक राजधानी वाई का उपयोग करके और रेगेक्स केस-असंवेदनशील (+1 बाइट) बनाकर बदल सकता था, लेकिन कोड-गोल्फ के लिए , प्रत्येक बाइट मायने रखता है, इसलिए मैंने फैसला किया कि मुझे वास्तव में पसंद है नींबू सबसे ज्यादा स्किल करता है।

टी एल; डॉ: Grape, Orange, Green Apple, Strawberry, Lemon

— गेब्रियल बेनामी
स्रोत

-0ध्वज आपको लगभग 10 बाइट

— दादा

इसके अलावा, मुझे डर है कि आप नियम से चूक गएFirst output shall be the first input

— दादा

1

दो बाइट बचाने के लिए अपनी खुद की निजी पसंद का त्याग करने के लिए आप पर अच्छा है

— wnnmaw

4

पर्ल, 30 31 33 + 2 = 32 33 35 बाइट्स

for$x(g,o,p,r){say;s/$x/ /&&redo}

-n0(2 बाइट पेनल्टी) के साथ चलाएं ।

जाहिरा तौर पर, मैं स्कैटल को वर्णमाला के क्रम में खाना पसंद करता हूं, क्योंकि यह कार्यक्रम इस तरह छोटा हो जाता है। कार्यक्रम को वास्तव में बहुत स्पष्टीकरण की आवश्यकता नहीं है: -n0इनपुट को अनुमानित रूप से पढ़ता है ( -nइसका मतलब है "इनपुट इनपुट को पढ़ें", -0इसका मतलब है "न्यूलाइन्स पर इनपुट न तोड़ें"); for$x(g..r)के साथ एक पाश चलाता $xसे प्रत्येक अक्षर से सेट gकरने के लिए rबदले में; say;किसी भी उत्परिवर्तन के बाद, वर्तमान इनपुट को प्रिंट करता है; यदि संभव हो तो एक स्थान के साथ (विशेष रूप से, पहले) s/$x/ /की एक प्रति बदल देता $xहै; और &&redoब्रेसिज़ के अंदर कोड को दोहराता है (यदि लूप काउंटर को आगे बढ़ाए बिना) अगर प्रतिस्थापन सफल रहा।

यह कार्यक्रम आसानी से अपनी लंबाई को बदलने के बिना स्केलेट के अधिक स्वादों के लिए सामान्यीकृत किया जा सकता है, और किसी भी आकार के ढेर के साथ काम करेगा।

यहाँ एक Ideone लिंक दिया गया है जहाँ आप इसका परीक्षण कर सकते हैं। (Ideone आपको कमांड-लाइन विकल्पों को निर्दिष्ट करने की अनुमति नहीं देता है, इसलिए मुझे शुरू में सेट करने के लिए कुछ लाइनें -n0और -M5.010आपको मुफ्त में मिलनी थीं ।)

1

मुझे यकीन नहीं है कि आपको कई बार एक ही बार ढेर के ढेर को मुद्रित करने की अनुमति है .. (वास्तव में मुझे लगता है कि आप नहीं कर सकते हैं) शायद स्विच करें say;for$x(g..r){say while s/$x/ /}?

— दादा

ठीक है। मैं मूल रूप से for$x(p,o,g,r)जो नहीं होता था । say whileकेवल एक बाइट लंबी है, और कुछ ऐसा है जिसे मैंने विकल्प के रूप में माना है, इसलिए मैं बस इसे बदल सकता हूं।

और आपको शुरू करने की आवश्यकता है say;क्योंकि नियम कहते हैंFirst output shall be the first input

— दादा

ओह, उस स्थिति में मैं उस for$x(g,o,p,r)संस्करण पर वापस जाऊंगा जो पहले इनपुट की नकल करता है। (यदि रंग गायब हैं तो खोज करने में कुछ अतिरिक्त समय लगता है, लेकिन आप किसी रंग के पैकेट में गायब होने की उम्मीद नहीं करेंगे।) रिकॉर्ड के लिए, say;पहले संस्करण के साथ 37 बाइट्स होंगे।

दादा की मूल टिप्पणी अभी भी खड़ी है, हालांकि - कोड के रूप में यह खड़ा होता है कभी-कभी एक पंक्ति में दो बार एक ही कॉन्फ़िगरेशन प्रिंट करेगा (एक बार साग के अंत में और दूसरी बार संतरे की शुरुआत में, जैसे)।

— DLosc

4

सी #, 134 148 बाइट्स

गण: G -> O -> Y -> P -> R

I=>{var v=new string(I)+";\n";int i,j=0,c;for(;j<4;){c="goyp"[j++];for(i=0;i<I.Length;i++)if(I[i]==c){ I[i]='.';v+=new string(I)+";\n";}}return v;};

@ पोक के उत्तर से कुछ इसी तरह की चीजों का इस्तेमाल किया, वर्तमान में थोड़ा लंबा है क्योंकि मुझे चरित्र सरणी को एक स्ट्रिंग में बदलने की आवश्यकता है;

— Yodle
स्रोत

हा! 3 चरों से हरा दिया !!!

— मुकुल कुमार

4

जावा 7, 139 135 130 151 138 135 बाइट्स

void t(char[]s){int i,j=-1;for(;++j<5;)for(i=-1;++i<109;)if(j>3|s[i]=="yogp!".charAt(j)){System.out.println(s);if(j>3)return;s[i]=32;}}

क्रम में खाती खाल: पीला, नारंगी, हरा, बैंगनी, लाल

मुझे लगता है कि यह 2 प्रिंट स्टेटमेंट>> से बेहतर है

— प्रहार
स्रोत

1

बेशक, आप कर सकते हैं, आपके फ़ंक्शन का नाम स्किट है: पी -3 वहीं!

— योडल

1

@Yodle उफ़! हाहाहा

— प्रहार

1

हम हमेशा एक 10x10 ग्रिड मिल रहा है तो मैं नहीं बल्कि का उपयोग कर thatn लंबाई हार्डकोड सकता हैs.length

— प्रहार

1

क्या हमें खाने से पहले इसे एक बार शुरू करने की ज़रूरत नहीं है: s

— Yodle

1

@ योडल यही कारण है कि मैं खा रहा हूँ "!" पहले skittles;) ... रुको मुझे लगता है कि मैं उस चाल को तोड़ दिया

— प्रोक

4

सी 145 - 5 - 18 - 1 = 121 बाइट्स

#define l(a)for(a=0;a<10;a++)
i,j,k,b='a';F(char a[][11]){while(b++<'x')l(i)l(j)if(a[i][j]==b){a[i][j]=32;l(k)puts(a[k]);puts("");}}

ungolfed + सुंदर

#include<stdio.h>
#include<windows.h>
i,j,k;
F(char a[][11])
{
    char b='a';
    while(b++<'x')
        for(i=0;i<10;i++)
            for(j=0;j<10;j++)
                if(a[i][j]==b)
                {
                    system("cls");
                    a[i][j]=32;
                    for(k=0;k<10;k++)
                        puts(a[k]);
                    puts("");
                    Sleep(35);
                }
}
main()
{
    char a[][11]={
            "gggggggggg",
            "goooooooog",
            "goppppppog",
            "goprrrrpog",
            "gopryyrpog",
            "gopryyrpog",
            "goprrrrpog",
            "gopppppppg",
            "goooooooog",
            "gggggggggg"
    };
    for(i=0;a[i][j];)
        puts(a[i++]);
    F(a);
}

यहाँ a[][11]11 की n-स्ट्रिंग्स लेने का मतलब है जहाँ 1 वर्ण समाप्ति के लिए आवश्यक है, तकनीकी रूप से केवल 10 दृश्यमान वर्ण।

आदेश: दिए गए इनपुट के
लिए यह फ़ंक्शन वर्णानुक्रमिक चेक करता है 'g'और इसे 1/1 से हटाता है, तब 'g'तक वैरिएबल होल्डिंग को बढ़ाता है जब तक कि यह अगला मैच (शायद पत्र 'o') नहीं मिलता है और फिर उन मिलान किए गए वर्णों को समाप्त कर देता है।
नकारात्मक पक्ष यह है कि यह फ़ंक्शन अभी भी सावधान है। इसलिए, यदि आपके स्किटल्स 26अलग-अलग रंगों के थे, जिन्हें अक्षर az से नाम दिया गया था, यह फ़ंक्शन उस इनपुट को भी संभाल लेगा ...

— मुकुल कुमार
स्रोत

3 से अधिक अब: पी

— योडल

@ योडल यस..थैंक टू मैक्रोज़ आप डिफाइन कर सकते हैं #define। इसने 19 बाइट्स काट लीं

— मुकुल कुमार

3

ऑक्टेव, 49 बाइट्स

वर्णमाला क्रम में ईट्स स्किटल्स, सबसे पहले एएससीआई-कोड।

A=input("");do [~,p]=max(A(:));A(p)=32 until A<33

— रेनर पी।
स्रोत

3

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

संपादन:

शून्य से 1 बाइट, के साथ टेम्पलेट शाब्दिक का उपयोग करके की

जावास्क्रिप्ट में एक गैर-पुनरावर्ती संस्करण।

golfed

s=>{r=s;for(c of`pogy`)while(s!=(s=s.replace(c,' ')))r+=`
`+s;return r}

इनपुट और आउटपुट मल्टीलाइन स्ट्रिंग्स हैं, "पर्पल => ऑरेंज => ग्रीन => येलो" ऑर्डर में गोलियां खाती हैं।

परीक्षा

S=s=>{r=s;for(c of`pogy`)while(s!=(s=s.replace(c,' ')))r+=`
`+s;return r}

console.log(
S(` org 
prgrg
gggpr
oyyor
 r p `)
);

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

— टसेपेल्लिन
स्रोत

2

पायथन 3 - 141 99 75 बाइट्स

s=input();[exec("print(s);s=s.replace(c,' ',1);"*s.count(c))for c in'orgy']

इस क्रम में स्कीट खाते हैं कार्यक्रम - Orange Red Green Yellow Purple।

संपादित करें - Flp.Tkc के लिए धन्यवाद जिन्होंने 24 बाइट्स को काटने में मदद की!

इनपुट - 
ygro गोपीप रिप्प रोपोग ऑर्गी

आउटपुट - 
ygro गोपीप रिप्प रोपोग ऑर्गी
ygr गोपुर rppog रिप्प ऑर्गी
ygr g ppr rppog rppog orgy
ygr जी ppr rpp जी rppog नंगा नाच
ygr g ppr आरपीपी जीआरपी जी ऑर्गी
ygr g ppr rpp जी rpp जी rgy
yg जी ppr rpp जी rpp जी rgy
yg जी पीपी आरपीपी जी आरपीपी जी rgy
yg जी पीपी पीपी जी आरपीपी जी rgy
yg जी पीपी पीपी जी पीपी जी rgy
yg जी पीपी पीपी जी पीपी जी जी
yg पीपी पीपी जी पीपी जी gy
y पीपी पीपी जी पीपी जी gy
y पीपी पीपी पीपी जी gy
y पीपी पीपी पीपी जी
y पीपी पीपी पीपी y
        पीपी पीपी पीपी वाई
        पीपी पीपी पीपी

मेरा मानना है कि इसे और अधिक निखारा जा सकता है क्योंकि यह बहुत सरल दिखता है।

— गुरुपाद ममदापुर
स्रोत

2

ऐसा लगता है कि यह सब एक समय में एक रंग खा रहा है जबकि इसे एक समय में केवल एक ही खाना चाहिए

— wnnmaw

1

इसके अलावा, आप एक घोंसले की सूची के रूप में इनपुट ले रहे हैं, लेकिन तार पैदा कर रहे हैं, कृपया अपने कोड को संशोधित करें जैसे कि इनपुट और आउटपुट दोनों एक ही प्रारूप हैं

— wnnmaw

@wnnmaw परिवर्तन किए गए। मुझे उम्मीद है कि यह अब ठीक है :)

— गुरुपद ममदापुर

1

मुझे पता है कि वहाँ पहले से ही एक छोटा सा समाधान है, लेकिन इस एल्गोरिथ्म के साथ रहकर आप इसे इस तरह से कुछ और कर सकते हैं ।

— 20

3

मुझे पसंद है कि कैसे आप विशेष रूप से आदेश है कि करने के लिए नेतृत्व चुना है orgy।

— निक हार्टले

2

विम 55 55 बाइट्स

मेरी लाइन सीमांकक को हटाकर दो बाइट्स बचा रहा है। दुर्भाग्य से यह पढ़ने के लिए और शुद्धता के लिए जाँच करने के लिए बहुत कठिन बनाता है :(।

:set ws!
yGP/o
qqnr G9kyGGp@qq@q/y
@q/p
@q/g
@qdG

Unprintables:

:set ws!
yGP^O/o
^Oqq^Hnr G9kyGGp@qq@q/y
^O@q/p
^O@q/g
^O@qdG

TryItOnline

आदेश oypg में खाती है, आर के सभी अंत के लिए छोड़कर :)

— nmjcman101
स्रोत

1

गणितज्ञ, 67 बाइट्स

Most[#/.(i=0;#:>"."/;i++≤0&/@Characters@"ryop")&~FixedPointList~#]&

खाती लाल, फिर पीला, फिर संतरे, फिर पुरी।

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

लड़का मुझे खुशी है कि इसके लिए कोई अंतर्निहित नहीं है

— wnnmaw 20

1

जावा 7, 125 बाइट्स

बैंगनी, पीला, हरा, लाल, नारंगी। मुझे मजा आ रहा है कि मैं इस समाधान में अपना आदेश चुनूं। : डी

golfed

String s(String p){String r=p;for(String c:"pygr".split(""))for(;p.contains(c);r+="\n\n"+p)p=p.replaceFirst(c," ");return r;}

Ungolfed

String s(String p) {
    String r=p;
    for (String c : "pygo".split("")) {
        for (; p.contains(c); r += "\n\n" + p) {
            p = p.replaceFirst(c, " ");
        }
    }
    return r;
}

यहाँ कोशिश करो!

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

चरणों के बीच विभाजन एक दोहरी न्यूलाइन के साथ किया जाता है \n\n, लेकिन अगर इनपुट ग्रिड को अंत में एक नई ट्रलाइन के साथ लिया जा सकता है, तो इसे छोटा किया जा सकता है \n।

— Xanderhall
स्रोत

1

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

f x|(a,b:c)<-span(<maximum x)x,b>'g'=(:)<*>f$a++' ':c|1<2=[]

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

*Main> mapM_ putStrLn $ f " org ,prgrg,gggpr,oyyor, r p "
 org ,prgrg,gggpr,o yor, r p 
 org ,prgrg,gggpr,o  or, r p 
 o g ,prgrg,gggpr,o  or, r p 
 o g ,p grg,gggpr,o  or, r p 
 o g ,p g g,gggpr,o  or, r p 
 o g ,p g g,gggp ,o  or, r p 
 o g ,p g g,gggp ,o  o , r p 
 o g ,p g g,gggp ,o  o ,   p 
 o g ,  g g,gggp ,o  o ,   p 
 o g ,  g g,ggg  ,o  o ,   p 
 o g ,  g g,ggg  ,o  o ,     
   g ,  g g,ggg  ,o  o ,     
   g ,  g g,ggg  ,   o ,     
   g ,  g g,ggg  ,     ,

सरल पुनरावृत्ति। वापसी मूल्य के लिए इनपुट सूची को सहेजें, gकिसी स्थान के साथ सबसे बड़े तत्व को बदलें और फ़ंक्शन को फिर से कॉल करें। आधार मामला तब है जब हटाने के लिए कोई तत्व नहीं बचा है।

— nimi
स्रोत

1

MATL, 24 बाइट्स

`tDX:t2#X>wx32w(10etun2>

इसे ऑनलाइन आज़माएं! मैं अपने वर्णों को उल्टे वर्णमाला क्रम में खाना पसंद करता हूं: हरा मेरा पसंदीदा रंग है। स्पष्टीकरण:

                           % Take input implicitly.
`                          % Start do ... while loop
 tD                        % Duplicate skittle pile (nom!), but give away for display
   X:                      % Put skittles in long row (like normal people do)
     t2#X>                 % Get least favourite skittle name and number in the row
          wx               % Discard the skittle name
            32w            % Put an eaten skittle on the stack (ASCII 32)
               (           % Put the eaten skittle back in the row of skittles.
                10e        % Shape the row back into a 10x10 array
                   tun     % Check the number of unique skittles
                      2>   % Loop while this number >2 (eaten skittles + favourite skittles)
                           % Implicit end of do... while loop. 
                           % Display last iteration implicitly, since it's still on the stack.

— Sanchises
स्रोत

0

QBasic, 125 बाइट्स

रचनात्मक नियमों का दुरुपयोग!

DATA 71,89,82,79
?INPUT$(109)
DO
READ s
FOR r=1TO 10
FOR c=1TO 10
IF s=SCREEN(r,c)THEN SLEEP 1:LOCATE r,c:?" "
NEXT
NEXT
LOOP

यह सबकुछ सही है

इनपुट और आउटपुट अपरकेस ( GORPY) हैं
इनपुट को क्रमिक 109 कुंजीपटों के रूप में लिया जाता है, जो पिछले एक में प्रवेश करने तक स्क्रीन पर प्रतिध्वनित नहीं होते हैं। अंतिम पंक्ति को छोड़कर प्रत्येक पंक्ति के अंत में, उपयोगकर्ता को एक गाड़ी वापसी दर्ज करनी चाहिए।
कई बार Skittles के ढेर को प्रिंट करने के बजाय, प्रोग्राम इसे स्क्रीन पर प्रत्येक चरण से पहले 1-सेकंड पॉज़ के साथ प्रदर्शित करता है। (QBasic में आउटपुट स्क्रॉलबैक नहीं है, इसलिए कई बार ढेर को प्रिंट करने से आपको केवल अंतिम 2 1/2 चरण मिलेंगे। इसके अलावा, यह विधि इस बात का बेहतर चित्रण है कि आपके खाने के साथ ही आपके Skittles का ढेर कैसे विकसित होता है।)
कार्यक्रम एक त्रुटि के साथ समाप्त होता है।

मेरे पास एक 130-बाइट संस्करण भी है जो लोअरकेस का उपयोग करता है और त्रुटि नहीं करता है।

यहां नमूने में चला है QB64 , साथ 109करने के लिए बदल 29एक 5x5 ग्रिड के लिए:

व्याख्या

DATA 71,89,82,79के ASCII कोड संग्रहीत करता है G, Y, R, और O।

?INPUT$(109) उपयोगकर्ता से 109 keypresses और उन्हें प्रिंट करता है।

हम फिर एक अनंत DO ... LOOPनिर्माण में प्रवेश करते हैं । हर बार के माध्यम से, हम READवर्तमान स्केच के ASCII कोड में s। फिर हम 1 से 10 तक पंक्तियों और स्तंभों पर लूप SCREEN(r,c)करते हैं। पंक्ति r, स्तंभ पर स्क्रीन पर वर्ण का ASCII कोड प्राप्त करता है c। यदि यह वर्तमान स्किटल के बराबर है s, हम SLEEPएक दूसरे के लिए और फिर से एक अंतरिक्ष प्रिंट r, c।

मुख्य लूप चार बार चलता है, हरे, पीले, लाल और नारंगी स्किटल्स को हटाता है। पांचवें पुनरावृत्ति पर, READत्रुटियां क्योंकि हम डेटा से बाहर हैं।

— DLosc
स्रोत

एक सामान्य व्यक्ति की तरह खाने की खाल

जेली , 16 14 13 बाइट्स

कैसे?

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

परीक्षण का मामला

दे घुमा के, 48, 46 बाइट्स

पायथन 2, 60 57 56 बाइट्स

पर्ल, 53 46 + 2 = 48 बाइट्स

पर्ल, 30 31 33 + 2 = 32 33 35 बाइट्स

सी #, 134 148 बाइट्स

जावा 7, 139 135 130 151 138 135 बाइट्स

सी 145 - 5 - 18 - 1 = 121 बाइट्स

ungolfed + सुंदर

ऑक्टेव, 49 बाइट्स

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

पायथन 3 - 141 99 75 बाइट्स

विम 55 55 बाइट्स

गणितज्ञ, 67 बाइट्स

जावा 7, 125 बाइट्स

golfed

Ungolfed

टिप्पणियाँ

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

MATL, 24 बाइट्स

QBasic, 125 बाइट्स

व्याख्या