42

कुछ लोग सारणीकरण और इंडेंटेशन के लिए रिक्त स्थान का उपयोग करने पर जोर देते हैं।

सारणीकरण के लिए, यह निर्विवाद रूप से गलत है। परिभाषा के अनुसार, सारणी के लिए सारणी का उपयोग किया जाना चाहिए।

यहां तक कि इंडेंटेशन के लिए, सारणी के उद्देश्य बेहतर हैं:

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

जैसा कि सभी कॉड ~~ई गोल्फ~~ आइर्स जानते हैं, कार्यक्रम यथासंभव कम होने चाहिए। न केवल यह हार्ड डिस्क स्थान को बचाता है, कम बाइट्स को संसाधित करने के लिए संकलन समय भी कम हो जाता है।
टैब चौड़ाई ^{1 को} समायोजित करके , एक ही फाइल प्रत्येक कंप्यूटर पर अलग-अलग दिखती है, इसलिए हर कोई वास्तविक फ़ाइल को संशोधित किए बिना अपनी पसंदीदा इंडेंट चौड़ाई का उपयोग कर सकता है।
सभी अच्छे टेक्स्ट एडिटर डिफ़ॉल्ट रूप से (और परिभाषा) टैबलेटर का उपयोग करते हैं।
मैं ऐसा कहता हूं और मैं हमेशा सही हूं!

अफसोस की बात है, हर कोई कारण नहीं सुनता है। किसी ने आपको एक फ़ाइल भेजी है जो इसे गलत ^टीएम कर रही है और आपको इसे ठीक करना होगा। आप इसे केवल मैन्युअल रूप से कर सकते हैं, लेकिन अन्य भी होंगे।

यह काफी बुरा है कि स्पेसर आपका कीमती समय बर्बाद कर रहे हैं, इसलिए आप समस्या का ध्यान रखने के लिए सबसे कम संभव प्रोग्राम लिखने का फैसला करते हैं।

कार्य

एक प्रोग्राम या एक फ़ंक्शन लिखें जो निम्न कार्य करता है:

एकल स्ट्रिंग को STDIN से या कमांड-लाइन या फ़ंक्शन तर्क के रूप में पढ़ें।
उन सभी स्थानों की पहचान करें जहाँ सारणीकरण या इंडेंटेशन के लिए रिक्त स्थान का उपयोग किया गया है।

रिक्त स्थान की एक रन इंडेंटेशन है यदि यह एक पंक्ति की शुरुआत में होती है।

का एक रन दो या अधिक रिक्त स्थान है सारणीयन अगर यह खरोज नहीं है।

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

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

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

उदाहरण

के सभी रिक्त स्थान
```
a    bc   def  ghij
```
सारणीकरण है।

रिक्त स्थानों की प्रत्येक रन 5 की चौड़ाई के लिए गैर-अंतरिक्ष वर्णों की पूर्ववर्ती स्ट्रिंग को पैड करती है, इसलिए सही टैब की चौड़ाई 5 है और सही आउटपुट ² है
```
a--->bc-->def->ghij
```
के पहले दो स्थान
```
ab  cde f
ghi jk lm
```
सारणीकरण, अन्य भ्रम हैं।

सही टैब की चौड़ाई 4 है, इसलिए सही आउटपुट ² है
```
ab->cde>f
ghi>jk lm
```
अंतिम स्थान अछूता रहता है, क्योंकि यह दो स्थानों के रूप में प्रस्तुत किया जाएगा यदि एक सारणी द्वारा प्रतिस्थापित किया जाए:
```
ab->cde>f
ghi>jk->lm
```
के सभी लेकिन एक रिक्त स्थान
```
int
    main( )
    {
        puts("TABS!");
    }
```
दूसरी ओर भ्रम है।

इंडेंटेशन स्तर 0, 4 और 8 रिक्त स्थान हैं, इसलिए सही टैब की चौड़ाई 4 है और सही आउटपुट ² है
```
int
--->main( )
--->{
--->--->puts("TABS!");
--->}
```
( )यदि एक सारणी द्वारा प्रतिस्थापित किया जाता है, तो अंतरिक्ष को तीन स्थानों के रूप में प्रस्तुत किया जाएगा, इसलिए यह अछूता रहता है।
के पहले दो स्थान
```
  x yz w
```
दूसरों के भ्रम की स्थिति है।

उचित टैब चौड़ाई 2 है और सही आउटपुट ² है
```
->x>yz w
```
अंतिम स्थान को दो स्थानों के रूप में प्रस्तुत किया जाएगा यदि एक सारणी द्वारा प्रतिस्थापित किया जाता है, तो यह अछूता रहता है।
के पहले दो स्थान
```
  xy   zw
```
इंडेंटेशन हैं, अन्य तीन सारणीकरण हैं।

केवल 1 टैब की चौड़ाई सभी स्थानों को खत्म करने की अनुमति देती है, इसलिए सही आउटपुट ² है
```
>>xy>>>zw
```
के सभी रिक्त स्थान
```
a b c d
```
भ्रम हैं।

सबसे लंबी संभव टैब चौड़ाई नहीं है, इसलिए सही आउटपुट ² है
```
a b c d
```

अतिरिक्त नियम

इनपुट में पूरी तरह से मुद्रण योग्य ASCII वर्ण और लाइनफ़ीड शामिल होंगे।
आप मान सकते हैं कि पाठ की अधिकतम १०० पंक्तियाँ और प्रति पंक्ति में अधिकतम १०० वर्ण हैं।
यदि आप आउटपुट के लिए STDOUT चुनते हैं, तो आप एक एकल अनुगामी लाइनफ़ीड मुद्रित कर सकते हैं।
मानक कोड-गोल्फ नियम लागू होते हैं।

¹ _{टैब की चौड़ाई को दो लगातार टैब स्टॉप के बीच वर्णों के बीच की दूरी के रूप में परिभाषित किया गया है , एक मोनोसैप्ड फ़ॉन्ट का उपयोग करके।}
² _{ASCII कला तीर सही तरीके से प्रस्तुत करने के लिए टैबैक्टर्स स्टैक एक्सचेंज को मना कर देता है, जिसके लिए मैंने एक बग रिपोर्ट प्रस्तुत की है। वास्तविक आउटपुट में वास्तविक टेबुलेटर होते हैं।}

— डेनिस
स्रोत

9

अंत में इस निरर्थक स्थान / टैब मुद्दे को आराम के लिए रखने के लिए: D

— Geobits

2

programs should be as short as possibleमुझे विश्वास है कि मुझे आर्थर व्हिटनी का लंबा-खोया भाई मिल गया है !!

— kirbyfan64sos

6

@ डेनिस " यह कहा, केवल एक मोरन अपने कोड को प्रारूपित करने के लिए टैब का उपयोग करेगा। " सर्वसम्मति, एह?

— प्रिमो

13

टैब्स अपवित्र डेमोंसपोन हैं जो अपने बिट्स को अलग करने के लायक हैं और उनके एएससीआईआई कोड को तब तक अपमानित किया जाता है जब तक कि उनकी अक्षम कमी-ए-आत्मा को अच्छी तरह से एक गूदे में जमीन नहीं दी गई हो। इर्रर, मेरा मतलब है, +1, अच्छी चुनौती, भले ही वह ईशनिंदा की बात करे। ;)

— दरवाज़े

1

मैं हर बार रो रहा था कि कोई सहकर्मी मेरे सुंदर अंतरिक्ष इंडेंट कोड में एक टैब जोड़ दे। तब मैंने विजुअल स्टूडियो में CTRL + K + F की खोज की। मैं इसे हर बार करता हूं जब मैं एक संशोधित फ़ाइल खोलता हूं। मेरा जीवन अब बेहतर है।

— माइकल एम।

5

पायथ, 102 103 बाइट्स

=T|u?<1hHiGeHGsKmtu++J+hHhGlhtH+tG]+HJ.b,YN-dk<1u+G?H1+1.)Gd]0]0cR\ .zZ8VKVNp?%eNT*hNd*/+tThNTC9p@N1)pb

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

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

संपादित करें: फिक्स्ड बग। बहुत धन्यवाद @aditsu

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

यह "एबीसी डी" पर दुर्घटनाग्रस्त हो जाता है

— एडिट्स

@aditsu बकवास! हेड-अप के लिए थैंक्स। मुझे बेहतर परीक्षण मामलों की आवश्यकता है: पी

— ब्रायन टक

5

पॉवरशेल, 414 409 बाइट्स

function g($a){if($a.length-gt2){g $a[0],(g $a[1..100])}else{if(!$a[1]){$a[0]}else{g $a[1],($a[0]%$a[1])}}}{$a[0]}else{g $a[1],($a[0]%$a[1])}}}
$b={($n|sls '^ +|(?<!^)  +' -a).Matches}
$n=$input-split"`n"
$s=g(&$b|%{$_.Index+$_.Length})
($n|%{$n=$_
$w=@(&$b)
$c=($n|sls '(?<!^| ) (?! )'-a).Matches
$w+$c|sort index -d|%{$x=$_.Index
$l=$_.Length
if($s-and!(($x+$l)%$s)){$n=$n-replace"(?<=^.{$x}) {$l}",("`t"*(($l/$s),1-ge1)[0])}}
$n})-join"`n"

मैं आगे बढ़ा और ;जहां आसानी से प्रदर्शन को संभव बनाने के बजाय नई लाइनों का उपयोग किया । मैं यूनिक्स लाइन के अंत का उपयोग कर रहा हूँ ताकि यह बाइट की गिनती को प्रभावित न करे।

कैसे निष्पादित करें

SpaceMadness.ps1फाइल में कोड कॉपी करें , फिर इनपुट को स्क्रिप्ट में पाइप करें। मैं मान लूंगा कि फ़ाइल को परिवर्तित करने की आवश्यकता है taboo.txt:

PowerShell से:

cat .\taboo.txt | .\SpaceMadness.ps1

कमांड प्रॉम्प्ट से:

type .\taboo.txt | powershell.exe -File .\SpaceMadness.txt

मैंने इसे PowerShell 5 के साथ परीक्षण किया, लेकिन इसे 3 या उच्चतर पर काम करना चाहिए।

परिक्षण

यहाँ एक त्वरित PowerShell विभाजन है जो उपरोक्त परीक्षण के लिए उपयोगी है:

[CmdletBinding()]
param(
    [Parameter(
        Mandatory=$true,
        ValueFromPipeline=$true
    )]
    [System.IO.FileInfo[]]
    $File
)

Begin {
    $spaces = Join-Path $PSScriptRoot SpaceMadness.ps1
}

Process {
     $File | ForEach-Object {
        $ex = Join-Path $PSScriptRoot $_.Name 
        Write-Host $ex -ForegroundColor Green
        Write-Host ('='*40) -ForegroundColor Green
        (gc $ex -Raw | & $spaces)-split'\r?\n'|%{[regex]::Escape($_)} | Write-Host -ForegroundColor White -BackgroundColor Black
        Write-Host "`n"
    }
}

इसे उसी निर्देशिका में रखें SpaceMadness.ps1, मैं tester.ps1इसे कॉल करता हूं , इसे कॉल करता हूं :

"C:\Source\SomeFileWithSpaces.cpp" | .\tester.ps1
.\tester.ps1 C:\file1.txt,C:\file2.txt
dir C:\Source\*.rb -Recurse | .\tester.ps1

तुम्हें नया तरीका मिल गया है। यह रूपांतरण के बाद प्रत्येक फ़ाइल की सामग्री को बाहर निकालता है, [RegEx]::Escape()जिसके माध्यम से दोनों रिक्तियाँ और टैब बचने के लिए होता है इसलिए यह वास्तव में देखने के लिए सुविधाजनक है कि वास्तव में क्या बदला गया है।

आउटपुट इस तरह दिखता है (लेकिन रंगों के साथ):

C:\Scripts\Powershell\Golf\ex3.txt
========================================
int
\tmain\(\ \)
\t\{
\t\tputs\("TABS!"\);
\t}

व्याख्या

बहुत पहली पंक्ति एक महान सामान्य कारक / विभाजक कार्य gको संक्षिप्त रूप में परिभाषित करती है जैसा कि मैं प्रबंधित कर सकता था, जो कि एक सरणी (संख्याओं की मनमानी संख्या) लेता है और यूक्लिडियन एल्गोरिथ्म का उपयोग करके जीसीडी की पुनरावृत्ति की गणना करता है ।

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

$bएक स्क्रिप्टब्लॉक को परिभाषित करता है क्योंकि नाराज होकर मुझे कोड के उस टुकड़े को दो बार कॉल करने की आवश्यकता होती है, इसलिए मैं उस तरह से कुछ बाइट्स बचा लेता हूं। यह ब्लॉक स्ट्रिंग (या स्ट्रिंग्स की सरणी) लेता है $nऔर उस पर एक रेगेक्स चलाता है ( slsया Select-String), मैच ऑब्जेक्ट लौटाता है। मैं वास्तव में एक ही बार में इंडेंटेशन और टेब्यूलेशन दोनों प्राप्त कर रहा हूं, जिसने वास्तव में मुझे अलग से कैप्चर करके अतिरिक्त प्रसंस्करण को बचाया।

$nमुख्य लूप के अंदर और बाहर अलग-अलग चीजों के लिए उपयोग किया जाता है (वास्तव में बुरा है, लेकिन यहां आवश्यक है ताकि मैं इसे $b's स्क्रिप्टब्लॉक में एम्बेड कर सकूं और लूप के अंदर और बाहर दोनों में एक लंबी param()घोषणा और गुजरती तर्कों के बिना उपयोग कर सकूं ।'

$s$bइनपुट फ़ाइल में लाइनों की सरणी पर ब्लॉक को कॉल करके, तब चौड़ाई को असाइन किया जाता है , फिर प्रत्येक मैच के सूचकांक और लंबाई को जोड़ते हैं, जीसीडी फ़ंक्शन में एक तर्क के रूप में रकम का सरणी लौटाते हैं। तो $sअब हमारे टैब का आकार बंद हो गया है।

फिर लूप शुरू होता है। हम इनपुट लाइनों के सरणी में प्रत्येक पंक्ति पर पुनरावृति करते हैं $n। लूप में जो पहली चीज मैं करता हूं $nवह उपरोक्त कारण के लिए वर्तमान लाइन का मान असाइन किया गया है।

$w केवल वर्तमान लाइन के लिए स्क्रिप्टब्लॉक कॉल का मूल्य मिलता है (वर्तमान लाइन के लिए इंडेंटेशन और टेबुलेशन)।

$cएक समान मूल्य मिलता है, लेकिन इसके बजाय हम सभी भ्रमों को पाते हैं ।

मैं जोड़ता हूं $wऔर $cजो एरेज़ हैं, मुझे सभी स्पेस मैचों के साथ एक सरणी देता है, जिसकी मुझे आवश्यकता है, sortयह इंडेक्स द्वारा अवरोही क्रम में है, और वर्तमान लाइन के लिए प्रत्येक मैच पर पुनरावृत्ति करना शुरू कर देता है।

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

इस लूप में, $xवर्तमान मैच के सूचकांक में है और वर्तमान मैच $lकी लंबाई है। $sवास्तव में हो सकता है 0और यह शून्य त्रुटि से एक विभाजनकारी विभाजन का कारण बनता है इसलिए मैं इसकी वैधता के लिए जाँच कर रहा हूं फिर गणित कर रहा हूं।

!(($x+$l)%$s)बिट एकल बिंदु जहाँ मैं देखने के लिए अगर एक जाँच है भ्रम की स्थिति किसी टैब या नहीं के साथ प्रतिस्थापित किया जाना चाहिए। यदि सूचकांक प्लस टैब चौड़ाई से विभाजित लंबाई शेष नहीं है, तो हम इस मैच को टैब के साथ प्रतिस्थापित करने के लिए अच्छे हैं (यह गणित हमेशा इंडेंटेशन और टैब्यूलेशन पर काम करेगा , क्योंकि उनका आकार टैब चौड़ाई निर्धारित करता है शुरुआत के लिए)।

प्रतिस्थापित के लिए, मैच लूप का प्रत्येक पुनरावृत्ति इनपुट की वर्तमान रेखा पर काम करता है, इसलिए यह प्रतिकृति का संचयी सेट है। रेगेक्स सिर्फ उन $lस्थानों की तलाश करता है $xजो किसी भी चरित्र से पहले हैं । हम इसे $l/$sटैब वर्णों (या यदि संख्या शून्य से नीचे है) से प्रतिस्थापित करते हैं ।

यह हिस्सा (($l/$s),1-ge1)[0]एक if (($l/$s) -lt 0) { 1 } else { $l/$s }वैकल्पिक रूप से कहने का वैकल्पिक तरीका है [Math]::Max(1,($l/$s))। यह एक सरणी बनाता है $l/$sऔर 1फिर, एक सरणी का उपयोग करता -ge 1है जिसमें केवल ऐसे तत्व होते हैं जो एक से अधिक या उसके बराबर होते हैं, फिर पहला तत्व लेता है। यह [Math]::Maxसंस्करण की तुलना में कुछ बाइट्स में आता है ।

एक बार जब सभी प्रतिकृति हो जाती हैं, तो वर्तमान लाइन को ForEach-Object( %) पुनरावृत्ति से लौटाया जाता है , और जब उन सभी को वापस कर दिया जाता है (निश्चित पंक्तियों की एक सरणी), तो यह -joinनईलाइन्स के साथ एड होता है (क्योंकि हम शुरुआत में नईलाइन्स पर विभाजित होते हैं)।

मुझे लगता है कि यहां सुधार के लिए जगह है कि मैं अभी पकड़ने के लिए बाहर जला दिया गया हूं, लेकिन शायद मैं बाद में कुछ देखूंगा।

टैब्स 4 लाइफ़

— briantist
स्रोत

4

PHP - 278 210 बाइट्स

फ़ंक्शन प्रत्येक टैब की चौड़ाई का परीक्षण करके काम करता है, 100 के मान से शुरू होता है, एक पंक्ति की अधिकतम लंबाई और इसलिए अधिकतम टैब की चौड़ाई।

प्रत्येक टैब की चौड़ाई के लिए, हम प्रत्येक रेखा को उस लंबाई के "ब्लॉक" में विभाजित करते हैं। इस ब्लॉक में से प्रत्येक के लिए:

यदि, इस ब्लॉक के साथ पिछले ब्लॉक के अंतिम चरित्र को समाप्‍त करके, हम एक चरित्र से पहले दो लगातार रिक्त स्थान पाते हैं, तो हमारे पास एक इंडेंटेशन या सारणीकरण है जो उपस्थिति को बदल दिए बिना अंतरिक्ष में परिवर्तित नहीं किया जा सकता है; हम अगले टैब की चौड़ाई की कोशिश करते हैं।
अन्यथा, यदि अंतिम वर्ण एक स्थान है, तो हम रिक्त स्थान को ब्लॉक के अंत में पट्टी करते हैं, एक सारणी जोड़ते हैं और पूरी बात को याद करते हैं।
अन्यथा, हम सिर्फ ब्लॉक को याद करते हैं।

एक बार जब एक पंक्ति के प्रत्येक ब्लॉक का विश्लेषण किया जाता है, तो हम एक लाइनफीड याद करते हैं। यदि सभी लाइनों के सभी ब्लॉकों का विश्लेषण सफलता के साथ किया गया था, तो हम उस स्ट्रिंग को वापस करते हैं जिसे हमने याद किया है। अन्यथा, यदि प्रत्येक कड़ाई से सकारात्मक टैब चौड़ाई की कोशिश की गई है, तो न तो सारणीकरण था, न ही इंडेंटेशन, और हम मूल स्ट्रिंग लौटाते हैं।

function($s){for($t=101;--$t;){$c='';foreach(split('
',$s)as$l){$e='';foreach(str_split($l,$t)as$b){if(ereg('  [^ ]',$e.$b))continue 3;$c.=($e=substr($b,-1))==' '?rtrim($b).'   ':$b;}$c.='
';}return$c;}return$s;}

यहाँ ungolfed संस्करण है:

function convertSpacesToTabs($string)
{
    for ($tabWidth = 100; $tabWidth > 0; --$tabWidth)
    {
        $convertedString = '';
        foreach (explode("\n", $string) as $line)
        {
            $lastCharacter = '';
            foreach (str_split($line, $tabWidth) as $block)
            {
                if (preg_match('#  [^ ]#', $lastCharacter.$block))
                {
                    continue 3;
                }

                $lastCharacter = substr($block, -1);
                if ($lastCharacter == ' ')
                {
                    $convertedString .= rtrim($block) ."\t";
                }
                else
                {
                    $convertedString .= $block;
                }
            }

            $convertedString .= "\n";
        }

        return $convertedString;
    }

    return $string;
}

2 बाइट्स बचाने के लिए डेंकेमेस का विशेष धन्यवाद ।

— ब्लैक होल
स्रोत

1

आप for($t=101;--$t;)इसके बजाय का उपयोग करके 2 बाइट्स बचा सकते हैंfor($t=100;$t;--$t)

— DankMemes

4

सीजेएम, 112

qN/_' ff=:e`{0:X;{_0=X+:X+}%}%_:+{~;\(*},2f=0\+{{_@\%}h;}*:T;\.f{\~\{@;1$({;(T/)9c*}{\;T{T%}&S9c?}?}{1$-@><}?}N*

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

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

स्पष्टीकरण:

qN/          read input and split into lines
_            duplicate the array (saving one copy for later)
' ff=        replace each character in each line with 0/1 for non-space/space
:e`          RLE-encode each line (obtaining chunks of spaces/non-spaces)
{…}%         transform each line
  0:X;       set X=0
  {…}%       transform each chunk, which is a [length, 0/1] array
    _0=      copy the first element (the length)
    X+:X     increment X by it
    +        and append to the array; this is the end position for the chunk
_            duplicate the array (saving one copy for later)
:+           join the lines (putting all the chunks together in one array)
{…},         filter the array using the block to test each chunk
  ~          dump the chunk (length, 0/1, end) on the stack
  ;          discard the end position
  \(         bring the length to the top and decrement it
  *          multiply the 2 values (0/1 for non-space/space, and length-1)
              the result is non-zero (true) iff it's a chunk of at least 2 spaces
2f=          get all the end positions of the multiple-space chunks
0\+          prepend a 0 to deal with the empty array case
{…}*         fold the array using the block
  {_@\%}h;   calculate gcd of 2 numbers
:T;          save the resulting value (gcd of all numbers) in variable T
\            swap the 2 arrays we saved earlier (input lines and chunks)
.f{…}        for each chunk and its corresponding line
  \~         bring the chunk to the top and dump it on the stack
              (length, 0/1, end position)
  \          swap the end position with the 0/1 space indicator
  {…}        if 1 (space)
    @;       discard the line text
    1$(      copy the chunk length and decrement it
    {…}      if non-zero (multiple spaces)
      ;      discard the end position
      (T/)   divide the length by T, rounding up
      9c*    repeat a tab character that many times
    {…}      else (single space)
      \;     discard the length
      T{…}&  if T != 0
        T%   calculate the end position mod T
      S9c?   if non-zero, use a space, else use a tab
    ?        end if
  {…}        else (non-space)
    1$-      copy the length and subtract it from the end position
              to get the start position of the chunk
    @>       slice the line text beginning at the start position
    <        slice the result ending at the chunk length
              (this is the original chunk text)
  ?          end if
N*           join the processed lines using a newline separator

— aditsu
स्रोत

1

PowerShell , 165 160 153 152 142 138 137 बाइट्स

param($s)@((0..99|%{$s-split"(
|..{0,$_})"-ne''-replace(' '*!$_*($s[0]-ne32)+' +$'),"`t"-join''})-notmatch'(?m)^ |\t '|sort{$_|% Le*})[0]

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

कम गोल्फ वाला:

param($spacedString)

$tabed = 0..99|%{
    $spacedString `
        -split "(\n|..{0,$_})" -ne '' `
        -replace (' '*!$_*($spacedString[0]-ne32)+' +$'),"`t" `
        -join ''
}

$validated = $tabed -notmatch '(?m)^ |\t '

$sorted = $validated|sort{$_|% Length}    # sort by a Length property

@($sorted)[0]  # $shortestProgram is an element with minimal length

— Mazzy
स्रोत

मेरे भगवान, यह रिक्त स्थान से भरा है!