तीन में विभाजित!

16

एक स्ट्रिंग को देखते हुए, आपको इसे तीन वर्णों के समूहों में विभाजित करना होगा ( _अंत में पैडिंग करके )।

संबंधित , लेकिन फिर भी यह अलग है।

नमूना I / O:

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

संपादित करें: अंत में, उत्पादन अप्रतिबंधित है ।

code-golf  string  array 
— राहुल वर्मा
स्रोत
10
क्यों विशेष मामला खाली स्ट्रिंग? क्या हम पैडिंग के लिए किस वर्ण का उपयोग कर सकते हैं?
— झबरा
12
तो कार्य वास्तव में है: एक स्ट्रिंग को देखते हुए, यदि यह खाली है, तो एक गलत मान लौटाएं, अन्यथा इसे तीन के समूहों में विभाजित करें, यदि आवश्यक हो तो अंडरस्कोर के साथ पैडिंग करें ? दो असंबंधित कार्यों की एक अजीब जोड़ी की तरह लगता है (स्ट्रिंग की लंबाई और विभाजन की जांच करना)।
— 15:19
15
बचने के लिए चीजें: असाधारण किनारे के मामले । इस स्थिति में, एक रिक्त स्ट्रिंग को खाली सरणी या समतुल्य होना चाहिए, न कि एक गलत मूल्य
— जो किंग
6
एक स्टेटमेंट से बहुत-सी वैधानिक रूप से टाइप की हुई भाषाएं एक से अधिक प्रकार से नहीं लौट सकती हैं
— को 'अज्ञानता का अवतार'
4
@manassehkatz हां, लेकिन केवल उन भाषाओं में। कुछ भाषाओं में यह समाधानों को अधिक जटिल बनाता है, या असंभव भी होता है (उदाहरण के लिए वैधानिक रूप से टाइप की गई भाषाएँ)।
— जो राजा

जवाबों:

8

पायथन 3, 58 47 34 बाइट्स

मुझे यकीन है कि कोई और बेहतर कर सकता है किसी और ने बेहतर किया। धन्यवाद जो राजा -11 -24 बाइट्स के लिए!

आउटपुट अप्रतिबंधित है, टपल नरक में आपका स्वागत है। खाली इनपुट पर खाली सूची ( झूठा ) लौटाता है

lambda x:[*zip(*[iter(x+"__")]*3)]

TIO

— बेंजामिन अर्कहार्ट
स्रोत
5

पर्ल 5 , 16 15 बाइट्स

"@_\__"=~/.../g

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

— केजेटिल एस।
स्रोत
1
15 के साथ "@_\__"=~/.../g। अन्य 16 थे: (pop.__)=~/.../gया map/.../g,pop.__।
— ग्रिमी
1
Thx to @Grimy टिप के लिए \ पर। इसने 1 बाइट का मुंडन किया और मैंने कुछ नया सीखा।
— केजेटिल एस
4

एपीएल + विन 36 36 22 बाइट्स

12 बाइट्स आउटपुट के परिणामस्वरूप अब डी-प्रतिबंधित हो गए हैं और @ Adám की पहली टिप्पणी में कोड का उपयोग करके एपीएल + विन में काम करने के लिए संशोधित किया गया है और उनकी दूसरी टिप्पणी के साथ एक और 2 है। धन्यवाद।

(⌈(↑⍴s)÷3)3⍴(s←⎕),'__'

स्ट्रिंग के इनपुट के लिए संकेत और परिणाम के रूप में एक nx3 सरणी

इसे ऑनलाइन आज़माएं! दरियाल क्लासिक के सौजन्य से

— ग्राहम
स्रोत
@ एडम। APL + जीत में एक डोमेन त्रुटि को सबसे सही पर फेंकता है
— ग्राहम
पर विफल '', नहीं? मुझे लगता है कि ओपी (कुछ अजीब कारण के लिए) परिणाम की आवश्यकता है 0(किसी भी रैंक के साथ)।
— 1947
1
@ Adám यह 0 x 3 एरे का उत्पादन करता है। ओपी अब एक अशक्त इनपुट के लिए "फ़ासी" चाहता है। इस कल्पना को बदलते रहने के साथ कि मैं इस बिंदु पर झुक जाऊंगा और अपना उत्तर इसके स्टैंड के रूप में छोड़ दूंगा! आपके सुधार के लिए धन्यवाद।
— ग्राहम
4

जावास्क्रिप्ट, ५१ ५० ४ 50 २। २५

b=>(b+"__").match(/.../g)

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

— VFDan
स्रोत
PPCG में आपका स्वागत है! :) लेकिन ... codegolf.stackexchange.com/a/185808/58974
— झबरा
@ शागिर्गी ने यह भी नहीं देखा कि hag \ _ (_) _ /
— V
कोई चिंता नहीं, ऐसा होता है।
— झबरा
3

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

{$_~"__"~~m:g/.../}

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

स्ट्रिंग को दो अंडरस्कोर से बांधें और फिर स्ट्रिंग को तीन वर्णों के टुकड़ों में विभाजित करें। मैच ऑब्जेक्ट की एक सरणी के रूप में लौटाता है।

— मजाक कर रहा है
स्रोत
3

जाप , 8 बाइट्स

+1 बाइट विशेष स्थिति के लिए खाली स्ट्रिंग। 2 बचा सकता है अगर हम अपना पैडिंग कैरेक्टर चुन सकते हैं।

©ò3 ú'_3

कोशिश करो

©ò3 ú'_3     :Implicit input of string
©            :Logical AND with
 ò3          :Split into chunks of 3
    ú'_3     :Right pad each with "_" to length 3
— झबरा
स्रोत
2

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

q'_3*+3/);p

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

खाली इनपुट के लिए यह एक खाली स्ट्रिंग देता है, जो गलत है।

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

q     e# Read input as a string
'_    e# Push char '_'
3*    e# String formed by that char repeated 3 times
+     e# Concatenate to input string
3/    e# Split in groups of 3, the last of which may be shorter. Gives array of strings
);    e# Detach last string from the array and delete it
p     e# Print string representation of the array
— लुइस मेंडो
स्रोत
2

रेटिना 0.8.2 , 10 बाइट्स

$
__
!`...

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

$
__

_अंतिम समूह को गद्देदार किए जाने की स्थिति में, दो एस लगाएं।

!`...

जितना संभव हो तीनों के कई समूहों से मिलान करें, गिनती के बजाय खुद को मैचों का आउटपुट दें। (रेटिना 1 में यह होगाL इसके बजाय! ।)

— नील
स्रोत
2

वोल्फ्राम भाषा (गणितज्ञ) , २ Language २१ बाइट्स

-7: Falseखाली इनपुट पर अब मिथ्या ( ) मान की आवश्यकता नहीं है

Partition[#,3,1,1,_]&

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

इनपुट के रूप में वर्णों की एक सूची लेता है। Blankएस ( _) के साथ गद्देदार वर्णों की 3-टुपल्स की सूची लौटाता है ।

34 27 बाइट्स

StringPartition[#<>"__",3]&

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

स्ट्रिंग इनपुट, स्ट्रिंग्स आउटपुट की सूची

— attinat
स्रोत
1

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

s3o€“___”

पात्रों की सूची को स्वीकार करने वाला एक मोनडिक लिंक, जो पात्रों की सूचियों की सूची तैयार करता है (एक खाली इनपुट खाली आउटपुट देता है)।

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

कैसे?

s3o€“___” - Link: list of characters
s3        - split into chunks of three
   €      - for each chunk:
  o       -   OR (vectorises):
    “___” -     list of characters = ['_', '_', '_']

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

समतुल्य 9:

o3ÐƤ“___”

कोशिश करो

वैकल्पिक 9:

;“___”s3Ṗ

कोशिश करो

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

जावा 10, 116 113 बाइट्स

s->{s+="__";int l=s.length()/3,i=l;var r=new String[l];for(;i-->0;)r[i]=s.substring(i*3,i*3+3);return l<1?0>1:r;}

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

या 104 101 बाइट्स यदि falseआउटपुट के रूप में एक खाली सरणी की अनुमति है ..

s->{s+="__";int l=s.length()/3;var r=new String[l];for(;l-->0;)r[l]=s.substring(l*3,l*3+3);return r;}

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

स्पष्टीकरण:

s->{                             // Method with String as both parameter and return-type
  s+="__";                       //  Append two "_" to the input-String
  int l=s.length()/3;            //  Get the length, integer-divided by 3
  var r=new String[l];           //  Create a string-array with that many parts
  for(;l-->0;)                   //  Loop `l` in the range (l, 0]:
    r[l]=                        //   Set the `l`'th value of the array to:
         s.substring(l*3,l*3+3); //   Get the substring of size 3 from index `l*3` from `s`
  return r;}                     //  Return the array
— केविन क्रूज़सेन
स्रोत
अब एक खाली सरणी की अनुमति है
— बेंजामिन Urquhart
1

रूबी, 73 42 बाइट्स

a=gets
a.length!=0?a.scan(/.{1,3}/).map{|s|(s+'_'*3)[0,3]}:'falsey value'

संपादित करें: जैसा कि गलत मूल्य लगता है कि यह आवश्यक नहीं है:

gets.scan(/.{1,3}/).map{|s|(s+'_'*3)[0,3]}
— मैक्स लैंगरैक
स्रोत
1
अधिकतम पैडिंग 2 वर्णों की है, इसलिए '_'*2यह पर्याप्त होगा, जिसके लिए एक शाब्दिक '__'छोटा है। लेकिन अगर आप पहले से पैडिंग जोड़ते हैं तो बस 3 अक्षरों से छोटे टुकड़ों से मेल नहीं खाते, कम है puts"#{gets}__".scan /.../:। (ध्यान दें कि स्पष्ट मुद्रण के बिना जिसे irbनहीं माना जाता है ruby)
— मैनटवर्क
1

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 74 बाइट्स

बस इनपुट के अंत में दो अंडरस्कोर '_' को सुनिश्चित करें कि यदि इनपुट की लंबाई 3 का कारक नहीं है तो वे मुद्रित करें।

s=>Enumerable.Range(0,(s.Length+2)/3).Select(i=>(s+"__").Substring(i*3,3))

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

— Innat3
स्रोत
67
— दाना
५
— mon
1

बैश , 90 बाइट्स

यह अधिक पारंपरिक बॉर्न शेल प्लस * निक्स कमांड के संयोजन के बजाय बैश सुविधाओं का उपयोग करता है (जो कि एक संस्करण जो मैंने 205 बाइट्स पर समाप्त किया है)। मैंने स्ट्रिंग में दो _ अक्षर जोड़ने के चकमा का उपयोग करके धोखा दिया। 

c=;read a;a=${a}__;while (($(echo ${#a})>2));do b=${a:0:3};c=$c\ $b;a=${a#$b};done;echo $c

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

— PJF
स्रोत
1

पावरशेल , 58 35 बाइट्स

$args-split'(...)'-ne''|% *ht 3 '_'

-23 बाइट्स mazzy के लिए धन्यवाद ।

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

— आंद्रेई ओडेगो
स्रोत
अच्छा लगा। 1) आप एक कोड की गिनती कर सकते हैं जिसे ps1-file में निकाला जा सकता है और निष्पादित किया जा सकता है। 2) शॉर्टकट देखें । 3) और अधिक गोल्फ करने की कोशिश करें
— mazzy
1

GNU sed , 27 बाइट्स

s:$:__:
s:...:& :g
s: _*$::

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

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

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

उपयोग:

echo -n ""|sed -f script

आउटपुट: कुछ भी नहीं छपा है, क्योंकि sed बिना इनपुट के भी स्क्रिप्ट को नहीं चलाता है।

B. एक अद्वितीय स्ट्रिंग होने के लिए sed के लिए मिथ्या मूल्य के रूप में विचार कर सकता है, यानी, केवल तभी वापस लौटा जब इनपुट एक खाली स्ट्रिंग है।

उपयोग:

echo ""|sed -f script

आउटपुट:

__

मैं पहली व्याख्या को इतना अधिक पसंद करता हूं, जैसा कि मेरा मानना ​​है कि यह नियत नियम के सबसे करीब है, लेकिन यदि आप उस TIO लिंक का उपयोग करके स्क्रिप्ट चलाते हैं तो आखिरी मदद करता है।

— seshoumara
स्रोत
0

अटैच , 34 23 बाइट्स

PadRight&"_"&3=>@Chop&3

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

स्पष्टीकरण (पुराना)

{On[#_-1,PadRight&"_"&3,_]}@Chop&3
                           @Chop&3    chop the input string into groups of 3s
{On[#_-1               ,_]}           on the last group
        ,PadRight                         pad it
                     &3                   to length three
                 &"_"                     with underscores
— कोनोर ओ ब्रायन
स्रोत
क्या आप केवल पिछले एक के बजाय सभी तत्वों को पैडिंग करके कुछ भी बचा सकते हैं ?
— झबरा
@ सुग्गी अच्छी बात! मैं इसे
— देखूंगा
0

चारकोल , 10 बाइट्स

Ｅ⪪Ｓ³…⁺ι__³

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

  Ｓ         Input string
 ⪪ ³        Split into groups of up to 3 characters
Ｅ           Map over each group
      ι     Current group
     ⁺      Concatenated with
       __   Literal `__`
    …    ³  Moulded to length 3
            Each group implicitly printed on its own line
— नील
स्रोत
0

बेफुंज -93 , 30 29 बाइट्स

~:1+%,~:1+!"`"*+,~:1+!"`"*+,,

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

एक खाली इनपुट के लिए आउटपुट कुछ भी नहीं है, अन्यथा एनयूएल वर्णों द्वारा अलग किए गए लंबाई 3 के तार आउटपुट।

स्पष्टीकरण:

~ ढेर करने के लिए इनपुट का चरित्र
 : 1+ डुप्लिकेट इनपुट और 1 जोड़ें
    % मोडुलो शीर्ष 2 स्टैक और पुश परिणाम के मान
                                यदि इनपुट -1 (स्ट्रीम का अंत) था, तो -1% 0 -> पड़ाव की गणना करें
                                अन्यथा इनपुट% (इनपुट + 1) -> इनपुट की गणना करें
     , पॉप और आउटपुट चरित्र
      ~ ढेर करने के लिए इनपुट का चरित्र
       : 1 +! डुप्लिकेट इनपुट, 1 जोड़ें और तार्किक नहीं करें
           "` '* 96 से गुणा (' '' के लिए ASCII कोड)
                                यह 96 या 0 रिटर्न के परिणाम पर निर्भर करता है
               + स्टैक से शीर्ष 2 मान जोड़ें और परिणाम को आगे बढ़ाएं
                                यदि इनपुट -1 (स्ट्रीम का अंत) था, तो '_' के लिए -1 + 96 = 95, या ASCII कोड को धक्का देता है।
                                अन्यथा इनपुट + 0 को धक्का देता है
                , पॉप और आउटपुट चरित्र
                 ~: 1 +! "" "* +, तीसरे वर्ण को संभालने के लिए फिर से वही ब्लॉक करें
                            , आउटपुट NUL वर्ण (स्टैक खाली है, इसलिए स्टैक से पॉपिंग केवल 0 देता है)

अनुदेश सूचक अंत में चारों ओर लपेटता है, पूरी लाइन को लूप करता है।
— नकारात्मक सात
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.