42

কিছু লোক ট্যাবুলেশন এবং ইনডেন্টেশনের জন্য স্পেস ব্যবহার করার জন্য জোর দেয়।

ট্যাবুলেশনের জন্য, এটি নির্বিচারে ভুল। সংজ্ঞা অনুসারে, ট্যাবুলেটরগুলি অবশ্যই টেবুলেশনের জন্য ব্যবহার করা উচিত।

এমনকি ইন্ডেন্টেশন করার জন্য, ট্যাবলেটরগুলি উদ্দেশ্যমূলকভাবে উচ্চতর:

আছে স্পষ্ট ঐক্যমত্য স্ট্যাক এক্সচেঞ্জ কমিউনিটি।
ইন্ডেন্টেশনের জন্য একটি একক স্থান ব্যবহার করা দৃশ্যত অপ্রীতিকর; একাধিক ব্যবহার করা অপচয়জনক।

সমস্ত কড ~~ই গল্ফ~~ এরস হিসাবে, প্রোগ্রামগুলি যতটা সম্ভব সংক্ষিপ্ত হওয়া উচিত। এটি কেবল হার্ড ডিস্কের স্থান সংরক্ষণ করে না, কম বাইটগুলি প্রক্রিয়া করতে হলে সংকলনের সময়গুলিও হ্রাস পেয়েছে।
ট্যাব প্রস্থ ¹ সামঞ্জস্য করে , প্রতিটি কম্পিউটারে একই ফাইল আলাদা দেখায়, তাই প্রত্যেকে আসল ফাইলটি পরিবর্তন না করেই তার প্রিয় ইনডেন্ট প্রস্থটি ব্যবহার করতে পারে।
সমস্ত ভাল পাঠ্য সম্পাদকরা ডিফল্টরূপে (এবং সংজ্ঞা) ট্যাবলেটর ব্যবহার করেন।
আমি তাই বলি এবং আমি সবসময় ঠিক!

দুঃখের বিষয়, সবাই যুক্তি শোনেন না। কেউ আপনাকে একটি ফাইল পাঠিয়েছে যা এটি ভুল ^{টিএম করছে} এবং আপনাকে এটি ঠিক করতে হবে। আপনি কেবল এটি ম্যানুয়ালি করতে পারতেন, তবে অন্যরাও থাকবেন।

এটি যথেষ্ট খারাপ যে স্পেসাররা আপনার মূল্যবান সময় নষ্ট করছে, তাই আপনি সমস্যার যত্ন নেওয়ার জন্য সংক্ষিপ্ততম প্রোগ্রামটি লেখার সিদ্ধান্ত নিয়েছেন।

কার্য

একটি প্রোগ্রাম বা একটি ফাংশন লিখুন যা নিম্নলিখিতগুলি করে:

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
```

অতিরিক্ত বিধি

ইনপুটটি পুরোপুরি মুদ্রণযোগ্য এএসসিআইআই অক্ষর এবং লাইনফিডের সমন্বয়ে গঠিত।
আপনি ধরে নিতে পারেন যে পাঠ্যটির সর্বাধিক 100 লাইন এবং প্রতি লাইনে সর্বাধিক 100 টি অক্ষর রয়েছে।
যদি আপনি আউটপুট জন্য STDOUT চয়ন করেন, আপনি একটি একক ট্রেলিং লাইনফিড মুদ্রণ করতে পারেন।
স্ট্যান্ডার্ড কোড-গল্ফ বিধি প্রযোজ্য।

¹ _{একটি মনসোপাসেড ফন্ট ব্যবহার করে টানা}_{দুটি ট্যাব স্টপগুলির মধ্যে অক্ষরের দূরত্ব হিসাবে ট্যাবের প্রস্থকে সংজ্ঞায়িত করা হয় ।}
² _{এএসসিআইআই শিল্প তীরগুলি ট্যাবলেটরদের উপস্থাপন করে স্ট্যাক এক্সচেঞ্জ সঠিকভাবে রেন্ডার করতে অস্বীকার করে, যার জন্য আমি একটি বাগ রিপোর্ট জমা দিয়েছি। আসল আউটপুটটিতে প্রকৃত ট্যাবলেটর থাকতে হয়।}

— ডেনিস
সূত্র

9

অবশেষে এই অযৌক্তিক স্থান / ট্যাব ইস্যুকে বিশ্রামে রাখার জন্য +1: ডি

— জিওবিটস

2

programs should be as short as possibleআমি বিশ্বাস করি আর্থার হুইটনির দীর্ঘ হারিয়ে যাওয়া ভাইকে আমি পেয়েছি !!

— kirbyfan64sos

6

@Dennis " তাই বলা হয়, শুধুমাত্র একটি বোকা তাদের কোড ফরম্যাট করতে ট্যাব ব্যবহার করেন। " , পরিষ্কার ঐক্যমত্য অঁ্যা?

— প্রিমো

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

এটি অনলাইনে চেষ্টা করুন

আকর্ষণীয় ধারণা, তবে যেহেতু ইনপুটটিতে থাকা ট্যাবগুলি ধারণাটি ভঙ্গ করে, খুব ব্যবহারযোগ্য নয়।

সম্পাদনা: স্থির বাগ। অনেক ধন্যবাদ @ অ্যাডিটসু

— ব্রায়ান টাক
সূত্র

এটি "abc d" এ ক্র্যাশ হয়েছে

— 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:

পাওয়ারশেল থেকে:

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

কমান্ড প্রম্পট থেকে:

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

আমি পাওয়ারশেল 5 দিয়ে এটি পরীক্ষা করেছি তবে এটি 3 বা ততোধিকের উপরে কাজ করা উচিত।

পরীক্ষামূলক

এখানে একটি দ্রুত পাওয়ারশেল স্ক্রিপ্ট যা উপরের পরীক্ষার জন্য দরকারী:

[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যতটা আমি পরিচালনা করতে পারি, এটি একটি অ্যারে নেয় (সংখ্যার স্বেচ্ছাসেবী সংখ্যা) এবং ইউসিডিডিয়ান অ্যালগরিদম ব্যবহার করে জিসিডি পুনরাবৃত্তভাবে গণনা করে ।

এর উদ্দেশ্য হ'ল প্রশ্নের দীর্ঘ সংজ্ঞা অনুসারে প্রতিটি ইনডেন্টেশন এবং ট্যাবুলেশনের সূচক + দৈর্ঘ্য নিয়ে "দীর্ঘতম সম্ভাব্য ট্যাব প্রস্থ" নির্ধারণ করা, তারপরে জিসিডি পাওয়ার জন্য এই ফাংশনটিতে এটি খাওয়ানো যা আমি মনে করি যে আমাদের পক্ষে সবচেয়ে ভাল best ট্যাব প্রস্থ জন্য না। একটি বিভ্রান্তির দৈর্ঘ্য সর্বদা 1 থাকবে তাই এটি এই গণনায় কোনও অবদান রাখে না।

$bস্ক্রিপ্টব্লকটি সংজ্ঞায়িত করে কারণ বিরক্তিকরভাবে আমাকে সেই টুকরা কোডটি দু'বার কল করতে হবে, তাই আমি কিছু বাইট সেভাবে সংরক্ষণ করি। এই ব্লকটি স্ট্রিং নেয় (বা স্ট্রিংগুলির অ্যারে) $nএবং এটির ( slsবা Select-String) এর উপর একটি রেজেেক্স চালায় , ম্যাচের অবজেক্টগুলি ফিরিয়ে দেয়। আমি এখানে একটিতে ইন্ডেন্টেশন এবং ট্যাবুলেশনগুলি উভয়ই পেয়ে যাচ্ছি, যা সত্যই আলাদাভাবে ক্যাপচার করে আমার অতিরিক্ত প্রক্রিয়াকরণটি সংরক্ষণ করেছিল।

$nমূল $bলুপটির অভ্যন্তরে এবং বাইরে বিভিন্ন জিনিস ব্যবহার করা হয় (সত্যিই খারাপ, তবে এখানে প্রয়োজনীয় তাই আমি এটির স্ক্রিপ্টব্লাকে এম্বেড করতে পারি এবং লুপটির অভ্যন্তরে এবং বাইরে উভয়ই লম্বা param()ঘোষণা এবং তর্ক ছাড়াই ব্যবহার করতে পারি ।

$s$bইনপুট ফাইলের লাইনের অ্যারেতে ব্লকটি কল করে , তারপরে প্রতিটি ম্যাচের সূচী এবং দৈর্ঘ্য যোগ করে, জিসিডি ফাংশনে যুক্তিরূপে যোগফলগুলির অ্যারে প্রদান করে ট্যাব প্রস্থকে বরাদ্দ করা হয়। সুতরাং $sআমাদের ট্যাবের আকার এখন স্টপ হয়েছে।

তারপরে লুপটি শুরু হয়। আমরা প্রতিটি লাইন ইনপুট লাইনের অ্যারেতে পুনরাবৃত্তি করি $n। লুপটিতে আমি প্রথম জিনিসটি হ'ল $nউপরের কারণে বর্তমান লাইনের মান নির্ধারিত (স্থানীয় সুযোগ)।

$w কেবলমাত্র বর্তমান লাইনের জন্য স্ক্রিপ্ট ব্লক কলটির মান পেয়েছে (বর্তমান লাইনের জন্য সূচকগুলি এবং ট্যাবুলেশনগুলি)।

$cএকটি অনুরূপ মান পায় তবে পরিবর্তে আমরা সমস্ত বিভ্রান্তি খুঁজে পাই ।

আমি যোগ করেছি $wএবং $cযা অ্যারেগুলি রয়েছে, আমাকে আমার প্রয়োজনীয় সমস্ত স্থানের ম্যাচগুলির সাথে একটি অ্যারে দেয়, sortএটি সূচক অনুসারে অবতরণ ক্রমে এবং বর্তমান লাইনের জন্য প্রতিটি ম্যাচে পুনরাবৃত্তি শুরু করে।

বাছাই গুরুত্বপূর্ণ। প্রথমদিকে আমি হার্ড উপায়টি জানতে পারি যে সূচকগুলির মানগুলির উপর ভিত্তি করে স্ট্রিংয়ের অংশগুলি প্রতিস্থাপন করা একটি খারাপ ধারণা যখন প্রতিস্থাপনের স্ট্রিংটি ছোট হয় এবং স্ট্রিংটির দৈর্ঘ্য পরিবর্তন করে! অন্যান্য সূচকগুলি অবৈধ হয়ে যায়। সুতরাং প্রতিটি লাইনে সর্বাধিক সূচকগুলি দিয়ে শুরু করে আমি নিশ্চিত হয়েছি যে আমি কেবল শেষ থেকে স্ট্রিংটি আরও সংক্ষিপ্ত করে তুলি এবং পিছনে সরে যাই যাতে সূচি সর্বদা কাজ করে।

এই লুপটিতে, $xবর্তমান ম্যাচের সূচীতে রয়েছে এবং বর্তমান ম্যাচের $lদৈর্ঘ্য। $sআসলে হতে পারে 0এবং এর ফলে শূন্য ত্রুটি দ্বারা একটি জটিল সমস্যা বিভক্ত হয়ে যায় সুতরাং আমি গণিতটি করার পরে এর বৈধতা যাচাই করছি।

!(($x+$l)%$s)বিট একক বিন্দু যেখানে আমি কিনা দেখতে একটি চেক আছে বিভ্রান্তি একটি ট্যাব বা না দিয়ে প্রতিস্থাপিত হবে। যদি ট্যাব প্রস্থের দ্বারা বিভক্ত সূচক এবং দৈর্ঘ্যের কোনও অবশিষ্ট থাকে না, তবে আমরা এই ম্যাচটি একটি ট্যাব দ্বারা প্রতিস্থাপন করা ভাল (এটি গণিত সর্বদা ইনডেন্টেশন এবং ট্যাবুলেশনে কাজ করবে , কারণ তাদের আকারটি ট্যাব প্রস্থ নির্ধারণ করে দিয়ে শুরু করতে).

প্রতিস্থাপনের জন্য, ম্যাচের লুপের প্রতিটি পুনরাবৃত্তি ইনপুটটির বর্তমান লাইনে কাজ করে, সুতরাং এটি প্রতিস্থাপনের একটি संचयी সেট। রেজেক্স কেবল এমন $lজায়গাগুলি সন্ধান করে $xযা কোনও অক্ষরের আগে রয়েছে। আমরা এটি $l/$sট্যাব অক্ষরের সাথে প্রতিস্থাপন করব (বা 1 যদি সেই সংখ্যাটি শূন্যের নীচে থাকে)।

এই অংশটি (($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

পিএইচপি - 278 210 বাইট

ফাংশনটি প্রতিটি ট্যাব প্রস্থকে পরীক্ষা করে, 100 টির মান দিয়ে শুরু করে, একটি লাইনের সর্বাধিক দৈর্ঘ্য এবং তাই সর্বাধিক ট্যাব প্রস্থ works

প্রতিটি ট্যাব প্রস্থের জন্য, আমরা প্রতিটি লাইনটিকে দৈর্ঘ্যের "ব্লক" এ বিভক্ত করি। এই প্রতিটি ব্লকের জন্য:

যদি, এই ব্লকের সাথে পূর্ববর্তী ব্লকের শেষ চরিত্রটি একত্রিত করে আমরা একটি অক্ষরের আগে দুটি ধারাবাহিক ফাঁকা স্থান খুঁজে পাই, আমাদের একটি ইনডেন্টেশন বা একটি সারণী রয়েছে যা চেহারা পরিবর্তন না করে মহাকাশে রূপান্তর করতে পারে না; আমরা পরবর্তী ট্যাব প্রস্থ চেষ্টা।
অন্যথায়, যদি শেষ অক্ষরটি একটি স্থান হয় তবে আমরা ব্লকের শেষে স্পেসগুলি সরিয়ে ফেলব, একটি ট্যাবুলেটর যুক্ত করব এবং পুরো জিনিসটি মুখস্থ করে তুলি।
অন্যথায়, আমরা কেবল ব্লকটি মুখস্থ করি।

একবার একটি লাইনের প্রতিটি ব্লক বিশ্লেষণ করা হয়ে গেলে, আমরা একটি লাইনফিড মুখস্থ করি। যদি সমস্ত লাইনের সমস্ত ব্লক সাফল্যের সাথে বিশ্লেষণ করা হয়ে থাকে, আমরা মুখস্থ করে রেখেছি return অন্যথায়, যদি প্রতিটি কঠোরভাবে ইতিবাচক ট্যাব প্রস্থের চেষ্টা করা থাকে, তবে টেবুলেশন ছিল না, বা ইনডেন্টেশনও ছিল না এবং আমরা মূল স্ট্রিংটি ফিরিয়ে দিই।

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;}

নিখরচায়িত সংস্করণটি এখানে:

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;)for($t=100;$t;--$t)

— ড্যাঙ্কমিমেস

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

পাওয়ারশেল , 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
সূত্র

আমার godশ্বর, এটি শূন্যস্থান পূর্ণ!