30

"देखो और कहो" या "कहो जो तुम देखते हो" अनुक्रम संख्याओं की एक श्रृंखला है जहां प्रत्येक अंतिम का वर्णन करता है।

1
11 (one one)
21 (two ones)
1211 (one two, one one)
111221 (one one, one two, two ones)
312211 (three ones, two twos, one one)

और पर और ... https://oeis.org/A005150

वैसे भी, दो तर्कों, एक प्रारंभिक संख्या और पुनरावृत्तियों की मात्रा लेने वाले कार्यक्रम को बनाने के लिए यह एक नियमित कोड गोल्फ चुनौती (कम से कम बाइट गिनती जीत) है। उदाहरण के लिए यदि आपने "1" और "2" में प्लग किया तो परिणाम "21" होगा। यदि आप "2" और "4" में प्लग करते हैं, तो परिणाम "132112" होगा। मज़े करो!

— HeyLlama
स्रोत

2

क्या हम अंकों की सूची प्राप्त / वापस कर सकते हैं?

— लीजियनममाल 978

5

यदि आवश्यक हो तो मैं पुराने प्रश्नों को बंद कर दूंगा; इस पर प्रतिबंध नहीं है।

— lirtosiast

4

मैं इसे डुप्लिकेट के रूप में नहीं देखता हूं। दोनों पिछले देखो और कहते हैं कि चुनौतियां बहुत प्रतिबंधात्मक थीं (स्रोत कोड में कोई संख्या नहीं, दूसरा बिना नाम वाले चर, नामित कार्य या नामित तर्क)। बहुत कम भाषाएँ पिछली चुनौतियों के जवाब देने की अनुमति देती हैं जो यहाँ भी प्रतिस्पर्धी हैं।

— ट्राइकोप्लाक्स

3

क्या हमें संख्याओं की सूची के रूप में आउटपुट की अनुमति है?

— lirtosiast

3

प्रतिबंधों के बिना डुप्लिकेट के बारे में मेटा पर चर्चा

— ट्राइकोप्लाक्स 15

9

अजगर, 10 8 बाइट्स

-2 बाइट्स @FryAmTheEggman द्वारा

ussrG8Qz

स्पष्टीकरण:

            Implicit: z=first line as string, Q=second line
u         the result of reducing lambda G:
  s s rG8   flattened run-length-encoded G
  Q       Q times
  z     starting with z

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

— lirtosiast
स्रोत

लेकिन कम से कम मैं कोष्ठक और अल्पविराम का उत्पादन नहीं करता; संख्याओं के बीच केवल रिक्त स्थान :-P

— लुइस मेंडो

2

सोवियत रूस में,ussrG8Qz

— mbomb007

8

सीजेएम, 8 बाइट्स

q~{se`}*

इनपुट प्रारूप प्रारंभिक संख्या है, पुनरावृत्तियों दूसरा, कुछ व्हाट्सएप द्वारा अलग किया गया है।

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

व्याख्या

q~   e# Read and evaluate input, dumping both numbers on the stack.
{    e# Run this block once for each iteration...
  s  e#   Convert to string... in the first iteration this just stringifies the input
     e#   number again. In subsequent iterations it flattens and then stringifies the
     e#   array we get from the run-length encoding.
  e` e#   Run-length encode.
}*

सरणी को मुद्रित करने से पहले भी चपटा किया जाता है ताकि परिणाम केवल आवश्यक संख्या हो।

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

6

जावास्क्रिप्ट, 57 बाइट्स

F=(a,b)=>b?F(a.replace(/(.)\1*/g,c=>c.length+c[0]),b-1):a

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

— Mwr247
स्रोत

आप एक अजीब पुनरावर्ती करी के साथ तीन बाइट्स बचा सकते हैं: b=>F=a=>b--?F(a.replace(/(.)\1*/g,c=>c.length+c[0])):aपाया कि मेरे जवाब को गोल्फ से पहले जब मैंने महसूस किया कि यह आपके लिए बहुत समान था;)

— ETHproductions

4

MATL , 9 बाइट्स

:"Y'wvX:!

इनपुट्स हैं: पुनरावृत्तियों की संख्या, प्रारंभिक संख्या।

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

:      % implicit input: number of iterations. Create vector with that size
"      % for loop
  Y'   %   RLE. Pushes two arrays: elements and numbers of repetitions.
       %   First time implicitly asks for input: initial number
  w    %   swap
  v    %   concatenate vertically
  X:   %   linearize to column array
  !    %   transpose to row array
       % implicitly end loop
       % implicitly display

— लुइस मेंडो
स्रोत

यदि आप एक सरणी के रूप में आउटपुट कर सकते हैं तो Pyth में 8. है

— lirtosiast

@ThomasKwa अच्छा बिंदु। मैंने माना कि यह संभव था

— लुइस मेंडो

4

आर, 87 बाइट्स

function(a,n){for(i in 1:n){r=rle(el(strsplit(a,"")));a=paste0(r$l,r$v,collapse="")};a}

अनगढ़ और समझाया गया

f=function(a,n){
    for(i in 1:n){                      # For 1...n
        r=rle(el(strsplit(a,"")))       # Run length encoding
        a=paste0(r$l,r$v,collapse="")   # concatenate length vector and values vector and collapse
    };
    a                                   # print final result
}

— Billywob
स्रोत

3

पर्ल 6, 63 बाइट्स

say (@*ARGS[0],*.trans(/(.)$0*/=>{$/.chars~$0})…*)[@*ARGS[1]]

यह उतना छोटा है जितना मैं इसे अभी तक प्राप्त कर सकता हूं, कुछ मुश्किल झंडे हो सकते हैं जो इसे कम कर सकते हैं, मुझे यकीन नहीं है

— हॉटकी
स्रोत

3

रूबी, 63 बाइट्स

एक पूर्ण कार्यक्रम, क्योंकि सवाल उस के लिए पूछना लगता है। कमांड लाइन तर्क के रूप में इनपुट लेता है।

i,n=$*
n.to_i.times{i=i.gsub(/(.)\1*/){"#{$&.size}#$1"}}
puts i

^{नहीं, का gsub!उपयोग नहीं किया जा सकता है, क्योंकि तार $*जमे हुए हैं: /}

— daniero
स्रोत

क्या आप शायद -pबाइट को बचाने के लिए झंडे का उपयोग कर सकते हैं ? यदि आप इसका उपयोग करते हैं, gsubतो STDIN की एक पंक्ति पर संचालित होता है जैसे कि यह था $_.gsub!। फिर कमांड लाइन तर्क पुनरावृत्तियों है, इसलिए n,=$*, और अन्य इनपुट STDIN से पढ़ा जाता है।

— मूल्य स्याही

3

रेटिना , 46 45 27 बाइट्स

मार्टिन ने गोल्फ की मदद करने के लिए बहुत कुछ किया।

+`(\d)(\1?)*(?=.*_)_?
$#2$1

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

प्रारूप में इनपुट लेता है:

<start><count>

<start> प्रारंभिक संख्या है।

<count> unary में है, सभी अंडरस्कोर हैं, और यह है कि कितने पुनरावृत्तियों का प्रदर्शन किया जाता है।

एकल पुनरावृत्ति, 20 16 बाइट्स:

(\d)(\1?)*
$#2$1

— mbomb007
स्रोत

3

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

import Data.List
0%y=y
x%y=do x<-group$(x-1)%y;[length x,x!!0]

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

— गेहूं का जादूगर
स्रोत

2

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

(m,n)=>[...Array(n)].map(_=>m=m.replace(/(.)\1*/g,x=>x.length+x[0]))&&m

एक स्ट्रिंग और एक संख्या के रूप में इनपुट लेता है।

— ETHproductions
स्रोत

('1',2)मुझे देता है 12, जब यह होना चाहिए 21। आपकी लंबाई को प्रतिस्थापित में चरित्र से पहले आना चाहिए।

— Mwr247

@ Mwr247 हुप्स, सॉरी।

— 20

2

पर्ल 5, 50 बाइट्स

$_=pop;for$i(1..pop){s/(.)\1*/length($&).$1/ge}say

तर्क उल्टे क्रम में हैं (पुनरावृत्तियों की संख्या तब बीज)। उदाहरण:

> perl -E'$_=pop;for$i(1..pop){s/(.)\1*/length($&).$1/ge}say' 4 2
132112
> perl -E'$_=pop;for$i(1..pop){s/(.)\1*/length($&).$1/ge}say' 0 2
2
> perl -E'$_=pop;for$i(1..pop){s/(.)\1*/length($&).$1/ge}say' 2 0
1110
> perl -E'$_=pop;for$i(1..pop){s/(.)\1*/length($&).$1/ge}say' 1 10
1110
> perl -E'$_=pop;for$i(1..pop){s/(.)\1*/length($&).$1/ge}say' 11 1
3113112221232112111312211312113211

— msh210
स्रोत

एक सबरूटीन के रूप में, मैं $_इसके बजाय इसे समाप्त करके एक बाइट दाढ़ी कर सकता हूं say, मुझे लगता है, लेकिन मैंने इसका परीक्षण नहीं किया है। वर्तमान समाधान एक कार्यक्रम है।

— msh210

2

05AB1E , 9 बाइट्स (गैर-प्रतिस्पर्धात्मक)

एमिग्ना की टिप्पणियों के कारण सही, नीचे देखें / संपादन।

F.¡vygyÙJ

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

— जादू ऑक्टोपस Urn
स्रोत

1

मुझे लगता है कि आप 2 तर्क (प्रारंभिक संख्या और पुनरावृत्तियों की संख्या) लेने के बारे में याद करते हैं। सौभाग्य से आप बस Fशुरुआत में जोड़ सकते हैं और तर्कों को ले सकते हैंiterations,initialNo

— Emigna

1

और बाइट कि द्वारा खो की जगह आ जा सकता है Dgsके साथ gy।

— Emigna

@Eignigna yउस संदर्भ में क्या करते हैं?

— मैजिक ऑक्टोपस Urn

1

पहले y के समान, लूप में वर्तमान मान को पुश करें। इसलिए y की नक़ल करने और उसे ऊपर से स्वैप करने के बजाय, आप ज़रूरत पड़ने पर उसे फिर से धक्का देते हैं।

— 21

@ एग्निमा लगता है मुझे अभी भी बहुत कुछ सीखना है।

— मैजिक ऑक्टोपस Urn

2

आर , 61 57 बाइट्स

-4 @JayCe के लिए धन्यवाद, बस जब मुझे यकीन था कि यह किसी भी सरल नहीं किया जा सकता है!

f=function(a,n)`if`(n,f(t(sapply(rle(c(a)),c)),n-1),c(a))

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

— J.Doe
स्रोत

1

थोड़ा गोल्फ: TIO

— JayCe

वह t(sapply(z,c))कॉल चालाक है।

— जे। सेप

1

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

FromDigits@Nest[Flatten[(Tally/@Split@#)~Reverse~3]&,IntegerDigits@#,#2]&

— एक सीमन्स
स्रोत

चार कोड के साथ अपने कोड को

— प्रेपेंड करें

1

जेली , 6 बाइट्स (गैर-प्रतिस्पर्धात्मक)

ŒrUFµ¡

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

           Implicit input: first argument.
     µ¡    Do this to it <second argument> times:
Œr            Run-length encode into [value, times] pairs
  U           Flip them
   F          Flatten list

— लिन
स्रोत

1

स्टैक्स , 10 बाइट्स

Çα▲ì4↔┌j█♀

भागो और डिबग ऑनलाइन!

उचित IO प्रारूप पर बहुत सारे बाइट्स खर्च किए ...

व्याख्या

समझाने के लिए अनपैक्ड संस्करण का उपयोग करता है।

DE|R{rm:f$e
D              Do `2nd parameter` times
 E             Convert number to digits
                   Starting from the `1st parmeter`
  |R           Convert to [element, count] pairs for each run
    {rm        Revert each pair
       :f      Flatten the array
         $     Convert array to string of digits
          e    Convert string of digits to integer

आवश्यक हिस्सा D|R{rm:f(8 बाइट्स) है।

यदि पहला इनपुट अंकों की एक सरणी के रूप में लिया जा सकता है, तो पूरे कार्यक्रम को 9 बाइट्स में लिखा जा सकता है: ऑनलाइन रन और डीबग करें!

— वीजुन झोउ
स्रोत

0

पायथन 3, 138 बाइट्स

मैंने एक पुनरावर्ती दृष्टिकोण का उपयोग किया।

def g(a,b):
 if b<1:return a
 else:
  c,n=1,'';f,*a=str(a)+'_'
  for i in a:
   if i==f:c+=1
   else:n+=str(c)+f;f,c=i,1
  return g(n,b-1)

फ़ंक्शन दो ints स्वीकार करता है, aऔर bजैसा कि वर्णित है।

मैं आश्चर्यचकित हूँ कि यहाँ प्रविष्टियाँ कैसे हैं! हो सकता है कि कोई बेहतर पायथन विधि के साथ भी आएगा।

— Ogaday
स्रोत

0

पर्ल, 38 + 2 बाइट्स

for$i(1..<>){s/(.)\1*/(length$&).$1/ge}

-pध्वज की आवश्यकता है :

$ perl -pe'for$i(1..<>){s/(.)\1*/(length$&).$1/ge}' <<< $'1\n5'
312211

इनपुट एक बहु पंक्ति स्ट्रिंग है:

input number
numbers of iterations

यदि सभी चरणों की आवश्यकता है, तो हम इसे निम्नलिखित में बदल सकते हैं, जो कि 44 + 2 बाइट्स हैं:

$ perl -nE'for$i(1..<>){s/(.)\1*/(length$&).$1/ge,print}' <<< $'1\n5'
11
21
1211
111221
312211

— andlrc
स्रोत

0

तोरण , ११

i:At,{n,A}j

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

i      # Get input from command line.
:A     # Initialize A
  t    # Set A to the top of the stack.
,      # Pop the top of the stack.
{      # Start a for loop.
 n     # Run length encode the stack.
  ,    # Seperate command and iteration
   A   # Repeat A times.
    }  # End for loop.
j      # Join the stack with '' and print it and then exit.

— मॉर्गन थ्रैप
स्रोत

0

स्माइलबासिक, 100 98 बाइट्स

DEF S N,T?N
WHILE""<N
C=C+1C$=SHIFT(N)IF C$!=(N+@L)[0]THEN O$=O$+STR$(C)+C$C=0
WEND
S O$,T-T/T
END

सभी चरणों को प्रिंट करता है। T/Tटी 0 है जब कार्यक्रम को समाप्त करने के लिए है।

— 12Me21
स्रोत

0

एपीएल (डायलॉग क्लासिक) , 22 बाइट्स

{∊(≢,⊃)¨⍵⊂⍨1,2≠/⍵}⍣⎕,⎕

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

— NGN
स्रोत

0

रेटिना , 27 बाइट्स

~(`^
K`
$
+`(.)\1$*¶$$.&$$1

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

— TwiNight
स्रोत

0

के (ngn / k) , 30 बाइट्स

{y{,/{(#x;*x)}'(&~=':x)_x}/,x}

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

— NGN
स्रोत

0

पायथन 3.6, 100 98 93 बाइट्स

import re
f=lambda s,n:n and eval("f'"+re.sub(r'((.)\2*)',r'{len("\1")}\2',f(s,n-1))+"'")or s

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

ध्यान दें कि यह एक लैम्बडा बनाता है जो एक स्ट्रिंग और पूर्णांक लेता है, और एक स्ट्रिंग लौटाता है। उदाहरण:f('1', 5) == '312211'

सभी दोहराए गए वर्णों ( ((.)\2*)regex) को ढूँढता है , अपनी लंबाई और वर्ण से बाहर एक f-string बनाता है ( r'{len("\1")}\2'), फिर उसका मूल्यांकन करता है। n and ...f(s,n-1)... or sएक उचित कार्य और एक लूप को परिभाषित करने से बचने के लिए काउंटर पर पुनरावर्तन का उपयोग करता है ।

— BoppreH
स्रोत

कहो तुम क्या देख रहे हो

अजगर, 10 8 बाइट्स

सीजेएम, 8 बाइट्स

व्याख्या

जावास्क्रिप्ट, 57 बाइट्स

MATL , 9 बाइट्स

आर, 87 बाइट्स

पर्ल 6, 63 बाइट्स

रूबी, 63 बाइट्स

रेटिना , 46 45 27 बाइट्स

एकल पुनरावृत्ति, 20 16 बाइट्स:

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

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

पर्ल 5, 50 बाइट्स

05AB1E , 9 बाइट्स (गैर-प्रतिस्पर्धात्मक)

आर , 61 57 बाइट्स

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

जेली , 6 बाइट्स (गैर-प्रतिस्पर्धात्मक)

स्टैक्स , 10 बाइट्स

व्याख्या

पायथन 3, 138 बाइट्स

पर्ल, 38 + 2 बाइट्स

तोरण , ११

स्माइलबासिक, 100 98 बाइट्स

एपीएल (डायलॉग क्लासिक) , 22 बाइट्स

रेटिना , 27 बाइट्स

के (ngn / k) , 30 बाइट्स

पायथन 3.6, 100 98 93 बाइट्स