অ-বৈষম্যমূলক প্রোগ্রামিং

74

আমরা বলি স্ট্রিংয়ের প্রতিটি অক্ষর একই সংখ্যায় এবং কমপক্ষে দুবার প্রদর্শিত হয় যদি একটি স্ট্রিং অ-বৈষম্যমূলক হয়।

উদাহরণ

  • "aa!1 1 !a !1"হয় অ পক্ষপাতমূলক অক্ষরের প্রতিটি কারণ , !, aএবং 1তিনবার প্রদর্শিত হবে।
  • "abbaabb"হয় না অ পক্ষপাতমূলক কারণ bপ্রায়ই আরো বেশী মনে হচ্ছে a।
  • "abc"এছাড়াও না অ পক্ষপাতমূলক কারণ অক্ষর কমপক্ষে দুইবার উপস্থিত হয় না।

কার্য

একটি লিখুন অ পক্ষপাতমূলক প্রোগ্রাম বা ফাংশন যা ফেরৎ truthy মান যদি একটি প্রদত্ত স্ট্রিং অ পক্ষপাতমূলক , এবং একটি falsy মান অন্যথায়।

এটি হ'ল প্রোগ্রামটি তার নিজস্ব উত্স কোডে চালিত হওয়া উচিত একটি সত্যবাদী মান।

প্রতিটি জমা দিতে হবে প্রিন্টযোগ্য এএসসিআইআই সমেত নন-খালি স্ট্রিংগুলি , পাশাপাশি জমা দেওয়ার উত্সের কোডটিতে উপস্থিত সমস্ত অক্ষর অবশ্যই পরিচালনা করতে সক্ষম হবে ।

পরীক্ষার মামলা

Truthy:

<your program's source code>
"aaaa"
"aa!1 1 !a !1"
"aabbccddeeffgg"
"1Q!V_fSiA6Bri{|}tkDM]VjNJ=^_4(a&=?5oYa,1wh|R4YKU #9c!#Q T&f`:sm$@Xv-ugW<P)l}WP>F'jl3xmd'9Ie$MN;TrCBC/tZIL*G27byEn.g0kKhbR%>G-.5pHcL0)JZ`s:*[x2Sz68%v^Ho8+[e,{OAqn?3E<OFwX(;@yu]+z7/pdqUD"

Falsy:

"a"
"abbaabb"
"abc"
"bQf6ScA5d:4_aJ)D]2*^Mv(E}Kb7o@]krevW?eT0FW;I|J:ix %9!3Fwm;*UZGH`8tV>gy1xX<S/OA7NtB'}c u'V$L,YlYp{#[..j&gTk8jp-6RlGUL#_<^0CCZKPQfD2%s)he-BMRu1n?qdi/!5q=wn$ora+X,POzzHNh=(4{m`39I|s[+E@&y>"
code-golf  string  decision-problem  restricted-source 
— Laikoni
সূত্র
4
@ লাইকোনি কি আমরা এটিতে কাজ পেতে মন্তব্যগুলিকে অপব্যবহার করতে পারি?
— ম্যাজিক অক্টোপাস উরন
6
পার্শ্ব নোট হিসাবে, আমি চ্যালেঞ্জগুলি পছন্দ করি যেখানে আমি আমার প্রবেশের বৈধতা পরীক্ষা করতে অন্যান্য এন্ট্রিগুলি ব্যবহার করতে পারি।
— ম্যাজিক অক্টোপাস উর্ন
3
@ ম্যাজিক অ্যাক্টোপাস ইউরান আমার ধারণা যে তিনি যে স্যান্ডবক্সে অনুমতি পেয়েছেন তাতে তিনি বলেছেন, যেহেতু এটি পর্যবেক্ষণের সাথে নির্ধারণ করা যায় না।
— এরিক আউটগলফার
11
যথাযথভাবে। এমনকি যদি আপনি কোনওভাবে কোনও উদ্দেশ্যমূলক ফ্যাশনে মন্তব্যগুলি নিষিদ্ধ করতে পরিচালনা করেন তবে অব্যবহৃত স্ট্রিং আক্ষরিক ect সম্পর্কে কী বলা যায়? যাইহোক, আমি মনে করি স্কোরিং যতটা সম্ভব মন্তব্য এড়ানোর জন্য উত্সাহ দেয়।
— লাইকনি
4
আমি এটি একটি ধাঁধা পেয়েছি, তবে "অভিন্ন বৈষম্যমূলক" যে "সমস্ত সনাক্তকারী লেবেলযুক্ত সদস্যের সাথে সমান অংশে উপস্থিত রয়েছে" এর সংমিশ্রণ সামান্য বিরক্তিকর ... "বৈষম্যমূলক" মানে "এর মধ্যে পার্থক্য বলা", এবং অন্য কাউকে অন্য শ্রেণীর লোকদের থেকে আলাদা হিসাবে দেখার ভিত্তিতে অন্যায়ের সাথে অন্যায় আচরণ করা বা বিচার করার অর্থ এটি অন্যায়ভাবে করা। অবশ্যই, মজা সঙ্গে চালিয়ে যান!
— এরিক

উত্তর:

37

ব্র্যাচল্যাগ , 10 বাইট

=ᵍbᵐbᵐlᵍ=l

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

ব্যাখ্যা

=ᵍ                Group all equal elements together
  bᵐbᵐ            Remove the first element of each group twice. This fails if
                  there are fewer than 2 elements
      lᵍ          Group elements together that have the same length
        =         Are all elements of that list equal? This only succeeds if the
                  list has one element
         l        Length. This will always succeed
— H.PWiz
সূত্র
25

জাভা 8, 198 192 186 174 168 165 160 বাইট (চার-গণনা 6 5)

o->{byte x[]=new byte[+333-3|2],u=-0,i,fe,fi,w; s:w:no0r3sswwyyy:for(int s:o){{u=++x[s];}};for(int b:x){if(!!!(2>b||u==b)|2>u|2>2){x[0]++;}}return!!(0>--x[0]);}

এটি অনলাইনে চেষ্টা করুন।
অক্ষরগুলির উপস্থিতি যাচাই করতে কোড ব্যবহৃত হত , যা এই চ্যালেঞ্জের জন্য আমার উত্তর ছিল ।

-5 বাইট ধন্যবাদ @ অলিভিগ্রগ্রোয়ারকে আবার মন্তব্যটি থেকে মুক্তি পেয়ে এবং গোলযোগ তৈরি করার জন্য ধন্যবাদ । ;)

পুরানো 168 বাইট (চার-গণনা 6) উত্তর :

o->{int w[]=new int[2222],u=0,f=0;for(int r:o)u=++w[r];for(int e:w)if(!(2>e|u==e)|2>u)f++;return!(f>0);}//[[[]]]  !!!!e(i)++,,,,-----oo////000tuww::::{{{{{;;||||}}}}}>>

এটি অনলাইনে চেষ্টা করুন।
কোড মন্তব্য বাদে অক্ষরের উপস্থিতি যাচাই করতে ব্যবহৃত হত , যা এই চ্যালেঞ্জের জন্য আমার উত্তর ছিল ।

-6 বাইটস @ অলিভারগ্রাগোয়ারকে< চেকগুলি অদলবদল করে মুছে ফেলার জন্য ধন্যবাদ >।

বেস গল্ফযুক্ত প্রোগ্রামের ব্যাখ্যা (98 বাইট):
এটি অনলাইনে চেষ্টা করুন।

s->{                     // Method with character-array parameter and boolean return-type
  int a[]=new int[256],  //  Occurrences integer-array containing 256 zeroes
      t=0,               //  Temp integer, starting at 0
      f=0;               //  Flag integer, starting at 0
  for(int c:s)           //  Loop over the input
    t=++a[c];            //   Increase the occurrence-counter of the current character
                         //   And set the temp integer to this value
  for(int i:a)           //  Loop over the integer-array
    if(i>1               //   If the value is filled (not 0) and at least 2,
       &i!=t             //   and it's not equal to the temp integer
       |t<2)             //   Or the temp integer is lower than 2
      f++;               //    Increase the flag-integer by 1
  return f<1;}           //  Return whether the flag integer is still 0

ব্যবহৃত চরিত্রের পরিমাণ হ্রাস করতে আমি কিছু কাজ করেছি:

  • পরিবর্তনশীল নামের o, w, u, f, r, এবং eপুনরায় ব্যবহার অক্ষর ইতিমধ্যে আমরা ছিল উদ্দেশ্যমূলকভাবে চয়ন করা হয়েছে (কিন্তু 6 অনধিক)।
  • 2222পরিবর্তে ব্যবহৃত হয় 256।
  • 6x সরানোর e>0&u!=e|u<2জন্য যদি চেকটি পরিবর্তন করা হয় ।!(e<2|u==e)|u<2&
  • দুই পৃথক আয় মুছে ফেলেছি এবং একটি পতাকা ব্যবহার করা f, এবং আমরা ফিরে আসতে তা শেষ এখনও 0 (এই বোঝানো আমি 6x দূর করতে পারবে byথেকে byteএখন যে আমরা কেবল ব্যবহার nমধ্যে int8 পরিবর্তে 6 বার)।
  • e<2এবং 6x এ এবং সরিয়ে নিতে u<2পরিবর্তন করা হয়েছে ।2>e2>u<

চর-কাউন্ট 6 থেকে 5 হ্রাস করতে আমি কী করেছি:

  • 2x intথেকে byteতাই nব্যবহৃত পরিমাণ 6 এর পরিবর্তে 4।
  • x[0]নতুন ভেরিয়েবলের পরিবর্তে ব্যবহৃত হয় f=0তাই =ব্যবহারের পরিমাণ 6 এর পরিবর্তে 5 হয়।
  • পরিবর্তিত 2222হয়েছে 3333তাই 2ব্যবহারের পরিমাণ 6 এর পরিবর্তে 2 হয়।
  • পরিবর্তনশীল ভেরিয়েবল fএবং rআবার যাতে তারা আর 6 হয় না।

@ অলিভিয়ার গ্রাগোয়ার মন্তব্যটি থেকে মুক্তি পেতে কী করেছেন এবং তাই 5x /:

  • অব্যবহৃত ভেরিয়েবল যুক্ত করা হচ্ছে ,i,fe,fi,w;।
  • অব্যবহৃত লেবেল যোগ করার পদ্ধতি: s:w:no0r3sswwyyy:।
  • অব্যবহৃত যোগ করা হচ্ছে |2>2
  • যোগ করা হচ্ছে {}প্রায় জন্য-loops এবং Ifs, এবং একটি অব্যবহৃত যোগ {}-block।
  • পরিবর্তন !করা হচ্ছে !!!।
  • পরিবর্তন |করা হচ্ছে ||।
  • বাম পাটিগণিত অপারেটরগুলি এবং এর থেকে মুক্তি 333পাওয়ার +333-3|2জন্য পরিবর্তন করা হচ্ছে ।+-|2
  • পরিবর্তন !(x[0]>0)করা হচ্ছে !!(0>--x[0])।
— কেভিন ক্রুইজসেন
সূত্র
1
180 বাইট : সমস্ত<মধ্যেপরিবর্তন>।
— অলিভিয়ের গ্রাগোয়ার
পছন্দ করুন
— কেভিন ক্রুইজসেন
পরিবর্তনটি এখনও 6 বাইট সংরক্ষণের জন্য প্রয়োগ করতে পারে।
— অলিভিয়ের গ্রাগোয়ার
নিকটেতম আমি 162 টি অক্ষর (161 অক্ষর) । আমি মন্তব্যটি সরিয়ে দেওয়ার চেষ্টা করছি, তবে এখনও আমার কোথাও কমা রাখা দরকার। আমি শুধু কোন জায়গা খুঁজে পাচ্ছি না।
— অলিভিয়ের গ্রাগোয়ার
1
160 বাইট ( প্রমাণ )। খুব সম্ভবত আরও গল্ফযোগ্য।
— অলিভিয়ার গ্রাগোয়ার
15

জেলি , 18 16 12 10 বাইট

Ġ¬zḊḊ¬zĠȦȦ

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

কিভাবে এটা কাজ করে

Ġ¬zḊḊ¬zĠȦȦ  Main link. Argument: s (string)

Ġ           Group the indices of s by their corresponding elements.
            "abcba" -> [[1, 5], [2, 4], [3]]

 ¬          Take the logical NOT of each 1-based(!) index.
            [[1, 5], [2, 4], [3]] -> [[0, 0], [0, 0], [0]]

   Ḋ        Dequeue; yield s without its fist element.
            "abcba" -> "bcba"

  z         Zip-longest; zip the elements of the array to the left, using the
            string to the right as filler.
            ([[0, 0], [0, 0], [0]], "bcba") -> [[0, 0, 0], [0, 0, "bcba"]]

    Ḋ       Dequeue; remove the first array of the result.
            This yields an empty array if s does not contain duplicates.
            [[0, 0, 0], [0, 0, "bcba"]] -> [[0, 0, "bcba"]]

    ¬       Take the logical NOT of all zeros and characters.
            [[0, 0, "bcba"]] -> [[1, 1, [0, 0, 0, 0]]]

      Ġ     Group.

     z      Zip-longest. Since all arrays in the result to the left have the same
            number of elements, this is just a regular zip.
            [[1, 1, [0, 0, 0, 0]]] -> [[1], [1], [[0, 0, 0, 0]]

       Ȧ    Any and all; test if the result is non-empty and contains no zeroes,
            at any depth. Yield 1 if so, 0 if not.
            [[1], [1], [[0, 0, 0, 0]] -> 0

        Ȧ   Any and all.
            0 -> 0
— ডেনিস
সূত্র
13

ব্র্যাচল্যাগ , 14 12 বাইট

ọtᵐℕ₂ᵐ==tℕ₂ọ

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

ব্যাখ্যা

ọ   Occurrences. Gives a list of [char, count] pairs for the entire input.
tᵐ  Map "tail" over this list, giving each character count.
ℕ₂ᵐ Make sure that each count is at least 2.
=   Make sure that all counts are equal.
    At this point we're done with the actual code, but we need another copy
    of each character (except ᵐ). We can just put them after this, as long as
    we make sure that they can never cause the predicate to fail.
=   Make sure that all counts are equal, again...
t   Extract the last count.
ℕ₂  Make sure that it's at least 2, again...
ọ   Get the digit occurrences in that count, this can't fail.

এর পরিবর্তে বিকল্প 12-বাইট সমাধান যা পুনরায় tব্যবহার করে ᵐ:

ọtᵐ==tℕ₂ℕ₂ọᵐ
— মার্টিন ইন্ডার
সূত্র
13

টি এসকিউএল, 320 বাইট (32 টি অক্ষর এক্স 10 10)

ইনপুট পূর্ব বিদ্যমান টেবিল মারফত FILLvarchar ক্ষেত্র সহ STEW, আমাদের আই মান অনুযায়ী ।

WITH BUMPF AS(SeLeCT GYP=1
UNION ALL
SeLeCT GYP+1FROM BUMPF
WHeRe GYP<=1000)SeLeCT
IIF(MIN(WAXBY)<MAX(WAXBY)OR
MAX(WAXBY)<=1,+0,+1)FROM(SeLeCT
WAXBY=COUNT(1),WHICH=+1+0,HEXCHANGE=+01,HUNG=+0+1,CHLUB=+0,GEFF=+0FROM
BUMPF,FILL WHERE
GYP<=LEN(STEW)GROUP BY
SUBSTRING(STEW,GYP,1))CHEXX
OPTION(MAXRECURSION 0)----------<<<<<<

কোডের টুকরো দিয়ে আমি আর কখনও সন্তুষ্ট, তবুও আতঙ্কিত হইনি।

কোনও সার্ভার বা ডেটাবেসে চালিত হতে হবে কেস-সংবেদনশীল কোলেশন সেট to উপরের এবং ছোট হাতের অক্ষর সহ 32 টি আলাদা আলাদা অক্ষরের প্রত্যেকটিতে 10 টি রয়েছে E(এসকিউএল কমান্ডগুলি কেস-সংবেদনশীল, তাই প্রয়োজনীয় হিসাবে কয়েকটি ফ্লিপ করা হয়েছে), স্পেস এবং ট্যাবগুলি (পাঠযোগ্যতার জন্য ট্যাবগুলি উপরের কোডে লাইন ব্রেক হিসাবে দেখানো হয়েছে)।

আমি কোডটিতে অন্যান্য চিহ্নগুলির প্রতিটি 10 ​​টি অন্তর্ভুক্ত করার উপায় খুঁজে পেয়েছি + = ,, তবে দুর্ভাগ্যক্রমে এটি করার কোনও উপায় খুঁজে পেলাম না <, তাই আমাকে মন্তব্য চরিত্রটি যুক্ত করতে হয়েছিল -।

আমি অতিরিক্ত সমস্ত ফিলারটি ক্র্যাম করার আগে ফর্ম্যাট কোডটি এখানে:

WITH b AS (SELECT g=1 UNION ALL SELECT g+1 FROM b WHERE g<1000)
SELECT IIF(MIN(w)<MAX(w) OR MAX(w)<1+1,0,1)
FROM(
    SELECT w=COUNT(1), --extra constant fields here are ignored
    FROM b, fill
    WHERE g < 1+LEN(stew)
    GROUP BY SUBSTRING(stew,g,1)
)a OPTION(MAXRECURSION 0)

শীর্ষ লাইনটি একটি পুনরাবৃত্ত সিটিই যা একটি সংখ্যা সারণী উত্পন্ন করে b, যা আমরা উত্সের স্ট্রিংয়ে অক্ষর দ্বারা পৃথক হওয়ার জন্য যোগদান করি। এই অক্ষরগুলি গোষ্ঠীভুক্ত করা হয়েছে এবং গণনা করা হয়েছে এবং IIFইনপুট স্ট্রিং অ-বৈষম্যমূলক কিনা তা নির্ভর করে বিবৃতিটি 0 বা 1 প্রদান করে।

— BradC
সূত্র
11

সি (জিসিসি) ,  333  168 বাইট

9 কেট বাঁচানোর জন্য কেভিন ক্রুইজসেনকে ধন্যবাদ এবং 45 লাইক বাঁচানোর জন্য @ লাইকোনিকে ধন্যবাদ!

f(r,h,a){char*o=r,c[222]={!o};for(a=!o;*o;)++c[*o++];for(h=!o;222/++h;c[h]&&c[h]!=a&&(a=!*c))!a&&c[h]&&(a=c[h]);r=!(2/2/a);}/////!(())****++,,,,,[[]]fffffrr{{{{{{}}}}}}

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

সি, 333 বাইট

i,v;f(S){char*s=S,L[128]={0};for(v=0;*s;)++L[*s++];for(i=-1;++i<128;L[i]&&L[i]-v?v=-1:0)!v&&L[i]?v=L[i]:0;return-v<-1;}/////////!!!!!!!!&&&&&(((((())))))******+++,,,,,,,----00000111122222228888888:::::::<<<<<<<===???????LLLSSSSSSS[[[]]]aaaaaaaacccccccceeeeeeeeffffffhhhhhhhhiinnnnnnnnooooooorrrrssssssttttttttuuuuuuuuvv{{{{{{{}}}}}}}

এমনকি বাইকোয়ান্টটিও বৈষম্যমূলক!

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

— Steadybox
সূত্র
ওহ্ ... আমি প্রথম মন্তব্য আপত্তিকারী হতে চাই। ভালো লাগছে তবে, আমি আপনার মতামতটির জন্য চরিত্রগুলি কীভাবে বাছাই হয়েছে তা পছন্দ করি
— ম্যাজিক অক্টোপাস উর্ন
1
আপনি এটা কমে যাবে 324 বাইট পরিবর্তন উভয় দ্বারা 128করতে 222তাই The 8বাদ করা যেতে পারে।
— কেভিন ক্রুইজসেন
1
পুনঃনামকরনের দ্বারা 279 বাইট i, v, S, sএবং Lঅক্ষর যা ইতিমধ্যে কীওয়ার্ড প্রদর্শিত করতে char, forএবং return: এটি অনলাইন ব্যবহার করে দেখুন!
— লাইকোনি
@ লাইকনি ধন্যবাদ! গতকাল আমার ঠিক মতো গল্ফ করার সময় হয়নি।
— স্টেডিবক্স
@ MagicOctopusUrn তাদের বাছাই করা হয়েছে কারণ আমি তাদের হাতে হাতে যোগ করতে খুব অলস ছিলাম ।
— স্টিডিবক্স
9

05 এ বি 1 ই , 20 18 16 14 বাইট

S¢Z≠sË*sZ¢≠SË*

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

প্রোগ্রামটি মূলত 2 অংশে বিভক্ত যেখানে প্রথম অংশের লক্ষ্যটি আসল কাজটি করা এবং দ্বিতীয় অংশের লক্ষ্য হল ফলাফলকে পরিবর্তন না করেই প্রথম অংশের মতো একই ফাংশনগুলি ব্যবহার করা।

ব্যাখ্যা (প্রথম অংশ)

S          # push input split into list of chars
 ¢         # count the occurrence of each char in input
  Z≠       # check that the max count is not 1
    sË     # check if all counts are equal
      *    # multiply

ব্যাখ্যা (দ্বিতীয় অংশ)

s          # swap input to top of stack
 Z¢        # count the number of occurrences of the largest element
   ≠       # check that the count isn't 1
    SË     # split into list and check that each element are equal (always true)
      *    # multiply (as it is with 1, the original result is left unchanged)
— Emigna
সূত্র
{γ€gDË*P≠qq{γ€gDË*P≠20% এর জন্য অন্য একটি)।
— ম্যাজিক অক্টোপাস উর্ন
1
@ ম্যাজিক অ্যাক্টপাস ইউরান: চমৎকার! আমার 20 বছর বয়সে আরও কয়েকজন ছিল। আমারও এখন 18-তে রয়েছে :)
— এমিগিনা
2
উইচক্র্যাফট! অন্য কোন ব্যাখ্যা!
— ম্যাজিক অক্টোপাস উরন
1
¢... ভাল ধারণা মানুষ, আমি দেখে খুশি হলাম ≠যেহেতু ভেবেছিলাম এটি হাহা হতে পারে!
— ম্যাজিক অক্টোপাস উর্ন 16
9

কাস্তে , 14 বাইট

§<ε#εu§m#u
m
<

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

ব্যাখ্যা

দুটি সংক্ষিপ্ত রেখার কোনও বিকল্প নেই, যেহেতু মূল কাজটি কখনই তাদের ডাকে না।

§<ε#εu§m#u  Implicit input, say S = "asasdd"
         u  Remove duplicates: "asd"
      §m#   For each, get number of occurrences in S: [2,2,2]
     u      Remove duplicates: L = [2]
   #ε       Number of elements in L that are at most 1: 0
  ε         1 if L is a singleton, 0 otherwise: 1
§<          Is the former value smaller than the latter?
— Zgarb
সূত্র
তবে এতে 'মি' এর চেয়ে 'ইউ' বেশি রয়েছে, সুতরাং এটি প্রয়োজনীয়তা পূরণ করে না।
— ডাব্লুগ্রোলাউ
@ ডাব্লুগ্রোলাও mদু'বার ঘটে: প্রথম লাইনে এবং দ্বিতীয় লাইনে। ব্যাখ্যাটিতে দুটি সংক্ষিপ্ত রেখা অন্তর্ভুক্ত করা হয়নি কারণ তারা প্রোগ্রামটির আচরণকে প্রভাবিত করে না।
— জাগারব
আমার ধারণা, ওপিকে অবশ্যই স্পষ্ট করে দেওয়া উচিত কিনা প্রোগ্রামটির সাথে প্রোগ্রামের ব্যাখ্যাটি স্ক্যান করা যায় কিনা। তবে বাস্তবে যদি আপনি এটি অন্তর্ভুক্ত করেন তবে আপনার চারটি 'ইউ' এবং দুটি 'এম' রয়েছে
— ডব্লিউগ্রোলাও
কিছু মনে করো না; এটি আমাকে একইভাবে বিভ্রান্ত করেছে অন্য উত্তরটি।
— ডাব্লুগ্রোলাউ
9

পাইথন 2 , 75 69 বাইট

def f(s):len({2<<s.count(c)-2for c,in s})<2or{{e.dil:-tu,r.dil:-tu,}}

আউটপুট উপস্থিতি বা ত্রুটির অনুপস্থিতির মাধ্যমে হয় । ত্রুটি হয় হয় একটি ভ্যালুএরার (এক বা একাধিক অক্ষর কেবল একবারই আসে) বা একটি নামেরর (চরিত্রের সংখ্যা অসম হয়)।

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

— ডেনিস
সূত্র
নেতিবাচক শিফট ত্রুটি কৌশলটি ঝরঝরে! আমি পছন্দ করি কীভাবে এটি শিফট অপারেটরের কম অগ্রাধিকারের সুবিধা নেয়।
— ভিনসেন্ট
1
{{e.dil:-tu,r.dil:-tu,}} শুভ প্রভু এটা কি?
— অ্যাডাম বার্নস
1
@ অ্যাডামবার্নস সিন্ট্যাক্টিক্যালি বৈধ গীব্রিশ যা মূল্যায়ন করা হলে একটি নেমরর ফেলে দেয় ।
— ডেনিস
আমি পাই না। আমি এটিকে অদলবদল করার চেষ্টা করেছি aএবং সবকিছু ভেঙে গেছে। আপনি আরও ব্যাখ্যা করতে পারেন দয়া করে?
— অ্যাডাম বার্নস
@ অ্যাডামবার্নস এটি কাজ করা উচিত, আপনি যতক্ষণ না পরে একটি স্থান ছেড়ে যান or। আমি যখন কম্পিউটারে থাকি তখন আমি একটি ব্যাখ্যা যুক্ত করব।
— ডেনিস
9

ব্র্যাচল্যাগ ভি 2, 8 বাইট (ব্র্যাচল্যাচের চরিত্রের সেটটিতে)

oḅ\k\koḅ

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

মনে হচ্ছে ব্র্যাচল্যাজে এই প্রশ্নটি নিয়ে একটি গল্ফিং যুদ্ধ চলছে, তাই আমি ভেবেছিলাম যে আমি যোগদান করব, পরবর্তী সেরা উত্তরের চেয়ে কয়েকটা বাইট সংরক্ষণ করব saving

এটি একটি সম্পূর্ণ প্রোগ্রাম যা অক্ষর কোডের তালিকা হিসাবে ইনপুট নেয়। (এটি আংশিক কারণ ব্র্যাক্ল্যাগের স্ট্রিংগুলিতে ব্যাকস্ল্যাশ সম্পর্কিত কিছু খুব উদ্ভট বাগ রয়েছে বলে মনে হয় এবং আংশিক কারণ \কমান্ডটি স্ট্রিংয়ের তালিকায় কাজ করে না))

ব্যাখ্যা

oḅ\k\koḅ
o          Sort {standard input}
 ḅ         Group identical adjacent values
  \        Assert rectangular; if it is, swap rows and columns
   k       Delete last element
    \      Assert rectangular; (rest of the program is irrelevant)

koḅশেষে অপ্রাসঙ্গিক; kসবসময় একটি উপাদান কাজ করে এবং করতে হবে oএবং ḅব্যর্থ করতে না পরেন তাহলে ইনপুট হিসাবে একটি তালিকা দেওয়া হয়েছে।

শুরু করার কারণটি oḅপরিষ্কার হওয়া উচিত; এটা মান ইনপুট তালিকা পার্টিশনগুলি যেমন [1,2,1,2,4,1]হয়ে [[1,1,1],[2,2],[4]]। প্রতিটি অক্ষর একই সংখ্যক বার প্রদর্শিত হওয়ার জন্য, এই তালিকাগুলির প্রত্যেকটিরই একই দৈর্ঘ্য হতে হবে, অর্থাৎ ফলাফলের তালিকাটি একটি আয়তক্ষেত্র। আমরা এই আয়তক্ষেত্রটি ব্যবহার করে জোর দিয়ে বলতে পারি \, যা সাইড এফেক্ট হিসাবে সারি এবং কলামগুলি স্থানান্তর করে।

অক্ষর সেটটির একাধিক অনুলিপি সহ এখন আমাদের বর্তমান মান রয়েছে, উদাহরণস্বরূপ যদি ইনপুটটি [4,2,1,2,4,1]বর্তমান মান হত [[1,2,4],[1,2,4]]। আমরা যদি একটি অনুলিপি মুছে ফেলি, ফলস্বরূপ ম্যাট্রিক্স এখনও আয়তক্ষেত্রাকার, তাই আমরা এটি ব্যবহার করে ফিরে ঘুরিয়ে দিতে পারি \। যাইহোক, যদি কারণ ম্যাট্রিক্স আয়তক্ষেত্রাকার ছিল যে সমস্ত ইনপুট অক্ষর স্বতন্ত্র ছিল, ফলে ম্যাট্রিক্স কোন উপাদান বাম থাকবে এবং \নেই না আয়তক্ষেত্রাকার (বরং ব্যর্থ) নামে একটি "0 × 0" ম্যাট্রিক্স আচরণ। তাই oḅ\k\কার্যকরভাবে দৃser়ভাবে দাবি করে যে ইনপুটটিতে প্রদর্শিত প্রতিটি অক্ষর একই সংখ্যক বার প্রদর্শিত হয় এবং বারের সংখ্যাটি 1 হয় না।

এটিই আমাদের প্রোগ্রামটির সম্পূর্ণ কার্যকারিতা (পুরো প্রোগ্রাম হিসাবে true, falseযদি কিছু দৃ did ়রূপে উত্থাপন না ঘটে তবে আমরা পাই )। যদিও আমাদের উত্সের বিন্যাসের সীমাবদ্ধতা মানতে হবে, সুতরাং আমি একটি অতিরিক্ত যুক্ত koḅকরেছি যার কোনও উদ্দেশ্য নেই তবে যা ব্যর্থ হতে পারে না (বিপরীতে \, oএবং ḅখালি তালিকায় কাজ করে খুশি)।

— ais523
সূত্র
1
— এরিক আউটগল্ফার
7

জাভাস্ক্রিপ্ট (নোড.জেএস) , 144 ... 100 96 বাইট

o=>!(a=o.split``.map(i=>o.split(i||aeehhhlmmnnnpst)[`length`]-1)).some(g=>![g>1][-!1]||a[-!1]-g)

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

24 টি বিভিন্ন অক্ষর * প্রতিটি 6 বার

২৮ টি বিভিন্ন অক্ষর * প্রতিটি 5 বার

২ different টি আলাদা আলাদা অক্ষর * প্রতিটি 5 বার

২ different টি আলাদা আলাদা অক্ষর * প্রতিটি 4 বার

26 টি বিভিন্ন অক্ষর * প্রতিটি 4 বার

25 টি বিভিন্ন অক্ষর * প্রতিটি 4 বার

24 টি বিভিন্ন অক্ষর * প্রতিটি 4 বার

ব্যাখ্যা 

o=>!(
 a=o.split``.map(                            // Split the input into character array and
  i=>o.split(i||aeehhhlmmnnnpst)[`length`]-1 // count the occurrences of each character.
 )
).some(                                      // Then check
 g=>![g>1][-!1]                              // If each character appears at least twice
 ||a[-!1]-g                                  // and the counts are all the same number.
)                                            

More to add:
1. Using {s.split``} instead of {[...s]} is to reduce the number of {.} that dominates
   the count.
2. Using {!c.some} instead of {c.every} to reduce the number of inefficient characters 
   (v,r,y in every)
3. Still one unavoidable inefficient character left ({h}).

Update:
1. Got rid of one {.} by replacing {.length} by {["length"]}.
2. Got rid of one {=} by replacing {c[-!1]!=g} by {c[-!1]-g}.
3. Got rid of one {()} by replacing {!(g>1)} by {![g>1][-!1]}.
4. Finally, because count per character is now 4, the backslashes can be taken out.

Update:
1. Got rid of all {"} by replacing {"length"} by {`length`} and exploiting shortcut
   evaluation. 
   {aaaeehhhlmmnnnpst} is not defined but is not evaluated either because of {c} which
   must be evaluated to true.

Update:
1. Got rid of all {c} by shortcutting the undefined variable at {split(i)} and replacing 
   all {c} by {a}.
   Since {i} is never an empty string, it is always evaluated true (except compared 
   directly to true).

Update:
1. Got rid of all {,} by moving the assignment after the argument list. The {()} at the
   front can therefore be moved to the assignment, retaining same number of {()}s.
— শিয়েরু আসাকোটো
সূত্র
6

পাওয়ারশেল , 104 বাইট

($qe=$args[0]| group |sort count|% count)[0]-eq$qe[-1]-and$qe[0]-gt1####((()))%%%pppddd===aaccss11nu|0gr

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

এটি গল্ফের জন্য দুর্দান্ত মজা ছিল। সীমাবদ্ধতাটি ছিল $, যা আমাদের কমপক্ষে চারটি প্রয়োজন ( $argsইনপুটটির জন্য একটি, গণনা ফলাফল নির্ধারণের জন্য একটি)$qe জন্য একটি, শেষ অক্ষরটি $qe[-1]পরীক্ষা করার জন্য একটি এবং প্রথম অক্ষরটি যাচাইয়ের জন্য $qe[0], যাতে কাজ করা সর্বাধিক সংখ্যক অক্ষর ছিল।

সেখান থেকে, গল্ফ করার বিষয়টি ছিল (এবং গল্ফিং নয়, যেমন দুটি অক্ষরের পরিবর্তনশীল নাম থাকার মতো) প্রোগ্রামটি চারটি দিয়ে সুন্দরভাবে বিভাজনযোগ্য করে তোলা। মনে রাখবেন যে #কিছু অনুপস্থিত উপাদানগুলির জন্য অ্যাকাউন্টে আমাদের কাছে একটি ছোট মন্তব্য (অনুসরণ করা সমস্ত কিছু) রয়েছে তবে আমি মন্তব্যটি যতটা সম্ভব ছোট রাখতে চেষ্টা করেছি।

— AdmBorkBork
সূত্র
6

হাস্কেল, 90 75 72 বাইট

a[i]|d:n<-[[i|n<-i,n==a]|a<-i]=and[[i]<d,[d|i<-n]==n]--aadd,,,,:::::<=||

প্রতিটি চরিত্র 6 বার প্রদর্শিত হয়। ইনপুট স্ট্রিংটি একটি সিঙ্গলটন তালিকা হিসাবে নেওয়া হয় ।

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

রেফারেন্সের জন্য, পুরানো সংস্করণ:

75 বাইট, প্রতিটি চর 5 বার

n(l)|d<-[[0|n<-l,n==a]|a<-l]=and[[0]<d!!0,all(==d!!0)d]--an!((())),,,0<[]||

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

90 বাইট, প্রতিটি চর 3 বার:

a x|h:u<-[sum[1|d<-x,not(d/=c)]|c<-x],"  \"\\&,../1::>acdlmmnosst">[]=h>1&&all(not.(/=h))u

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

— nimi
সূত্র
6

পাইথন 2 , 108 104 92 88 বাইট

থেকে -12 বাইট ধন্যবাদ রড
থেকে -4 বাইট ধন্যবাদ কেভিন Cruijssen

s=input();c=s.count;print[all(c(s[[]>[1]])==c(o)>1. for o in s)];aaafffillpprrtuu>1.>1.;

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

— ovs
সূত্র
1
আপনার প্রোগ্রামটি অবশ্যই বৈষম্যমূলক হতে হবে।
— ব্যবহারকারী 202729
1
প্রোগ্রামটি অবশ্যই অ-বৈষম্যমূলক হতে হবে।
— হাইপারনিউটারিনো
@ user202729 আমাকে বলার জন্য ধন্যবাদ, আমি আমার উত্তর আপডেট করেছি।
— ovs
1
s=input();c=s.count;print[all(c(s[[]>[1]])>=c(o)>1. for o in s)];aaafffillpprrtuu=1.>1.; মন্তব্য থেকে মুক্তি পেয়ে 88 বাইট ।
— কেভিন ক্রুইজসেন 21
1
— ভিনসেন্ট
6

এমএটিএল , 12 বাইট

q&=sqt&=tsvv

ইনপুটটি একক উদ্ধৃতিতে আবদ্ধ একটি স্ট্রিং। স্ট্রিংয়ের একক উদ্ধৃতিগুলি সদৃশ হয়ে পালিয়ে যায়।

আউটপুটটি একটি নন-খালি ম্যাট্রিক্স, যা সত্যবাদী যদি এতে জিরো না থাকে এবং এটি কমপক্ষে শূন্য থাকে তবে মিথ্যা হয়।

এটি অনলাইন চেষ্টা করুন! বা সুবিধার জন্য স্ট্যান্ডার্ড সত্যতা / মিথ্যাচার পরীক্ষা সহ সমস্ত পরীক্ষার কেস যাচাই করুন ।

কিভাবে এটা কাজ করে

চিহ্নিত (*)চিহ্নগুলি প্রয়োজনীয় বা ক্ষতিকারক নয় এবং এগুলি কেবল উত্স কোডটিকে বৈষম্যমূলক করার জন্য অন্তর্ভুক্ত করা হয়েছে।

q     % Implicit input. Convert chars to code points and subtract 1 from each (*)
&=    % Square matrix of all pairwise equality comparisons
s     % Sum of each column. Gives a row vector
q     % Subtract 1 from each value. An entry equal to 0 indicates the input string
      % is discriminating because some character appears only once
t     % Duplicate
&=    % Square matrix of all pairwise equality comparisons. An entry equal to 0
      % indicates the input string is discriminating because some character is
      % more repeated than some other
t     % Duplicate (*)
s     % Sum of each column (*) (all those sums will be positive if the previous
      % matrix doesn't contain zeros)
v     % Vertically concatenate the matrix and the vector of its column sums
v     % Vertically concatenate the resulting matrix with nothing (*)
      % Implicit display
— লুইস মেন্ডো
সূত্র
5

পার্ল 5 ,-p 57 বাইট

প্রতিটি চরিত্র 3 বার উপস্থিত হয়। কেবল একা 1কিছু করতে পারে না

অ-বৈষম্যমূলক করার জন্য 12 বাইটগুলি একটি মৌলিক 45 অক্ষর সমাধানে যুক্ত করা হয়

s{.}[@m[@1{$&}+=$.].=g]eg;$\=s()(e@m;1)&&m[e(\sg+)\1+;]}{

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

— টন হসপেল
সূত্র
5

আর , 90 বাইট

"?"=`u\164f8ToI\x6Et`;'!'=prod;!{y<-xtabs(~?readLines())}%in%{z<-y[1]}&z>T##&[]>~48bEfILpu

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

TRUEবৈষম্যহীন স্ট্রিংয়ের FALSEজন্য এবং বৈষম্যমূলক স্ট্রিংয়ের আউটপুট । আমি এই সাইটে চ্যালেঞ্জের জন্য অনেক কুৎসিত কোড লিখেছি, তবে আমি মনে করি এটি এখন পর্যন্ত কুরুচিপূর্ণ।

45 টি অক্ষর, প্রতিটি দু'বার ব্যবহার করা হয়েছে (একটি মন্তব্যে কয়েকটি সহ)। আগের সেরা আর উত্তরটি ছিল 116 বাইট , 29 টি অক্ষর প্রতিটি 4 বার ব্যবহৃত হয়; আমি এটি আলাদাভাবে পোস্ট করছি কারণ এটি যথেষ্ট আলাদা sub

কোডটি সমান

y = table(utf8ToInt(readLines()))
z = y[1]
all(y == z) & (z > 1)

যা ইনপুটটিকে পূর্ণসংখ্যার ভেক্টরে রূপান্তরিত করে, yমানগুলির একটি সংকীর্ণ টেবিলটি গণনা করে, তারপরে পরীক্ষা করে যে table টেবিলের সমস্ত গণনা প্রথম গণনার সমান এবং প্রথম গণনা 1 এর চেয়ে বড় is

প্রাথমিক অসুবিধাটি ছিল মাত্র 2 জোড়া বন্ধনী ব্যবহারের ক্ষেত্রে। এই ইউনারী ফাংশন redefining করে এটা করা যায় !এবং ?করা utf8ToIntএবং prodযথাক্রমে। (আমি ব্যবহার করতে পারি না allকারণ আমার দরকার আছে a)। চারটি অ্যাসাইনমেন্ট রয়েছে: দুটি সহ =এবং দুটি সাথে<- । এর অর্থ এই যে সমতা পরীক্ষা মধ্যে yএবং zব্যবহার করতে পারবেন না y==zকিংবা y-z; y%in%zউদ্ধার করতে আসে।

এই ফাংশনগুলি সংজ্ঞায়িত করা সমস্ত সম্ভাব্য উদ্ধৃতিগুলি ব্যবহার করে: দুটি ডাবল উদ্ধৃতি, দুটি একক উদ্ধৃতি এবং আমার পরবর্তী অনুচ্ছেদে দুটি ব্যাকটিক লাগবে, তাই আমাকে অবলম্বন করতে হয়েছিল readLines() পরিবর্তে হবে scan(,"")। (অন্যান্য বিকল্পগুলি, যেমন scan(,letters)বা scan(,month.abb)সমস্ত একটি মূল্যবান ব্যবহার করে t যা আমি ছাড়াই না))

: এই মুহুর্তে, আমি বিল্ডিং ব্লক অধিকাংশ ছিল utf8ToInt, prod, table, readLines, %in%। তিনটি অক্ষর ঐ নামে তিনবার প্রদর্শিত: ent। প্রথম, আমি আবিষ্কার করেছিলাম যে table(foo)এটি xtabs(~foo)সংরক্ষণের সমতুল্য e। আমি nএবং tহেক্স / অষ্টাল কোড ট্রিক দিয়ে উদ্ধার করতে পারি ; গল্ফিয়েস্ট সলিউশনটি হ'ল u\164f8ToI\x6Et(ব্যাকটিক্সে) এর জন্য ব্যবহার করা utf8ToInt।

— রবিন রাইডার
সূত্র
এটি চিত্তাকর্ষক আপনি দুটি কেস 90 টি বাইটে (এবং সহায়তা অপারেটরের চমৎকার অপব্যবহারের) ক্ষেত্রে বৈষম্যমূলক করতে পারেন তবে হায় হায় NAসত্যবাদী মান হিসাবে বিবেচনা করা হয় না (আর, যদি (এনএ) x অন্য কোনও ত্রুটির কারণ হয়ে থাকে, তাই NAসত্যবাদী বা মিথ্যাও নয় )
— জেডিএল
1
@ জেডিএল ধন্যবাদ, আপনি ঠিক বলেছেন। সর্বশেষতম সম্পাদনাটি এই সমস্যার সমাধান করে।
— রবিন রাইডার
1
@ জেডিএল মন্তব্যগুলি পরামর্শ দেয় যে ধারাবাহিক, স্বতন্ত্র উত্তর সত্য এবং মিথ্যাচারের জন্য ঠিক ok
— জিউসেপ
@ জিউসেপ আসলে, আমি কয়েক সেকেন্ড আগে এই সমস্যাটি সমাধান করেছি (নতুন সংস্করণ দেখুন, যা বেশ আলাদা তবে একই বাইট গণনা); এখন সত্য এবং মিথ্যা ফলাফল দেয়।
— রবিন রাইডার
4

ব্র্যাচল্যাগ , 18 বাইট

oḅlᵐ=h≥2
oḅlᵐ=h≥2

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

দুর্ভাগ্যক্রমে, আমি লাইনফিডগুলি অপসারণ করতে পারছি না, যেহেতু ḅসংখ্যায় ব্যর্থতা ট্রিগার করে।

— এরিক দ্য আউটগল্ফার
সূত্র
লাইনফিডের প্রয়োজন নেই এমন ছোট কিছু করা অবশ্যই সম্ভব (তবে আপনাকে কিছু জিনিস বদলের দরকার হতে পারে);)
— 14:38 এ ফ্যাটালাইজ করুন
@ ফ্যাটালাইজ বর্তমানে কোন সময় নেই, এবং হ্যাঁ আমি এই আলোচনাটি পড়েছি। :)
— এরিক আউটগল্ফার
4

রুবি , 87 78 বাইট

c=->m{y=m.chars;x=y.map{|d|y.count d}|[];x[-1]>1and not x[1]};->{pushrortpush}

26 টি অক্ষর প্রতিটি 3 বার পুনরাবৃত্তি

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

— আসোন তুহিদ
সূত্র
@ নিমিমি এটি দেখানোর জন্য ধন্যবাদ, আমি মনে করি এটি getsএবং এর সাথে কিছুটা অদ্ভুততা ছিল ;। এটি পরিবর্তিত হয়েছে, এটি যাইহোক
— লাম্বদা
3

আর, 132 116 বাইট

crudcardounenforceableuploads<-function(b){{pi&&pi[[1-!1]];;;"";{1<{f<<-table(strsplit(b,"",,,)[[1]])}}&&!!!sd(-f)}}

এটিতে কোনও মন্তব্য বা অতিরিক্ত অতিরিক্ত স্ট্রিং নেই, যদিও কোড গল্ফটিতে কোনও ফাংশন ডাকার ক্ষেত্রে এটি সম্ভবত আমার সময় হবে crudcardounenforceableuploads। ফাংশন নামের জন্য কোথাও সম্ভবত একটি দুর্দান্ত অ্যানগ্রাম আছে!জন ডিভোরাককে ধন্যবাদ একটি সুন্দর অ্যানগ্রাম ইনস্টলকারকে নির্দেশ করার জন্য, যা আমি নামের জন্য ব্যবহার করেছি।

চরিত্রের সারণী:

- , ; ! " ( ) [ ] { } & < 1 a b c d e f i l n o p r s t u 
4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4

উদাহরণ:

> crudcardounenforceableuploads("aaabbbccc")
[1] TRUE
> crudcardounenforceableuploads("aaabbbcc")
[1] FALSE
> crudcardounenforceableuploads("abc")
[1] FALSE
> crudcardounenforceableuploads("crudcardounenforceableuploads<-function(b){{pi&&pi[[1-!1]];;;\"\";{1<{f<<-table(strsplit(b,\"\",,,)[[1]])}}&&!!!sd(-f)}}")
[1] TRUE
— JDL
সূত্র
বাইট গণনা গুরুত্বপূর্ণ কিনা তা জানেন না তবে আমরা >তুলনামূলকভাবে তুলনাটি স্যুইচ করে সম্ভবত 2s এবং গুলি সরাতে পারি f। =পরিবর্তে ব্যবহার করতে পারেন <<-। strsplitসম্ভবত অপরিবর্তনীয় যদিও এটি অন্যান্য চরিত্রের বেশিরভাগের উত্স।
— জেডিএল
আপনার কি স্পেস দরকার? আপনি এর utf8ToIntপরিবর্তে চেষ্টাও করতে পারেন strsplit, তবে নিশ্চিত হন না যে এটি সাহায্য করবে কিনা। এছাড়াও সম্ভবত টিআইওর একটি লিঙ্ক অন্তর্ভুক্ত করবেন?
— জিউসেপ্পে
সমস্ত .মনে হয় অতিরিক্ত অতিরিক্ত।
— জিউসেপে
এটি কোড-গল্ফ , সুতরাং আপনার মন্তব্য অনুযায়ী বাইট গণনা গুরুত্বপূর্ণ।
— জিউসেপে
2
কিছু সম্ভাব্য অ্যানাগ্রাম: কোনও পাইপ-বন্ধিত আলমারি আমলাতন্ত্র নয়; আরআইপি কার্বনেসিয়াস বারবিকিউড পাউন্ড ডিপ। ওয়ার্ডপ্লেস
— জন ডিভোরাক
2

বেস 144 বাইট

grep -o .|sort|uniq -c|awk '{s=$1}{e[s]=1}END{print((s>1)*(length(e)==1))}##>>>#|'#wwwuuutrqqqppooNNNnlllkkkiihhhggEEEDDDcccaaa1***{}[[[]]]...--''

কোডের এই লাইনটি ইনপুট হিসাবে স্টিডিন স্ট্রিং নেয়। "গ্রেপ -ও।" প্রতিটি অক্ষর একটি নতুন লাইনে রাখে। "ইউনিীক-সি" প্রতিটি অধ্যায়টির ব্যবহার গণনা করে। আরজিক স্ক্রিপ্ট প্রতিটি ব্যবহারকে আলাদা উপাদান হিসাবে একটি অ্যারে তৈরি করে, এবং কেবলমাত্র 1 টি অ্যারে সূচক থাকে এবং মান কমপক্ষে 2 হয় তবে ফলাফলগুলি সত্য হয় Each প্রতিটি অক্ষর 4 বার ব্যবহৃত হয়, সুতরাং এই উত্সটি সত্য ফিরে আসে

— কালেব
সূত্র
2

স্ট্যাক্স , 26 24 18 বাইট

:u{m*_{y#m:u_hy#h*

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

এখন পর্যন্ত সংক্ষিপ্ত সমাধান যা কেবলমাত্র মুদ্রণযোগ্য এএসসিআইআই ব্যবহার করে দ্বারা প্রহারযোগ্য করে।

অনুমান করুন আমি সমস্যাটি ভুল উপায়ে পৌঁছেছি। একটি ওয়ার্কিং ব্লকের পুনরাবৃত্তি গোলাপী বা আকর্ষণীয় নয়। এখন কমপক্ষে এটি আরও ভাল দেখাচ্ছে ...

ব্যাখ্যা

:u{m* কিছু আবর্জনা উত্পাদন করে যা আউটপুটকে প্রভাবিত করে না।

_{y#m:u_hy#h*
_{y#m           map each character to its number of occurences in the string
     :u         all counts are equal (result 1)
       _hy#     get the count of appearance for the first character
           h    halve it and take the floor, so that 1 becomes 0(result 2)
            *   multiply the two results
— ওয়েইজুন ঝো
সূত্র
@WGrolau কোন চরিত্র একবার উপস্থিত হয়? আপনি কি আমার উত্তরটি যথেষ্ট মনোযোগ দিয়ে পড়েছেন?
— ওয়েজুন ঝো
'#' ':' এর চেয়ে প্রায়শই বেশি উপস্থিত হয় (কেবল একটি উদাহরণ)। ওহো, অশুদ্ধ পাঠ (অন্যান্য মন্তব্য দেখুন)
— WGroleau
@WGrolau ঠিক দু'জন #এবং দুটি :গুলি আছে, আপনি কি আমার উত্তরটি দ্বিতীয় লাইনে পড়েছেন? আপনি কি আমার "ব্যাখ্যা" তে প্রথম অনুচ্ছেদটি এড়িয়ে গেছেন?
— ওয়েজুন ঝো
দুঃখিত, ব্যাখ্যার উপরের লাইনটি পুরো জিনিসটি ভেবেছিল।
— ডাব্লুগ্রোলাউ
1

পিপ , 22 বাইট

I1&MY$=_Y_NaMa$=y&1NIy

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

ব্যাখ্যা

প্রতিটি চরিত্র দু'বার ঘটে।

                        a is first command-line argument
I1&MY$=_                No-ops to make the program non-discriminating
            Ma          Map this function to the characters of a:
         _Na             Count occurrences of each character in a
        Y               Yank the result into y
              $=y       Fold y on equals: truthy if all elements are equal
                 &      Logical and
                  1NIy  1 is not in y
                        Autoprint the result of the last expression

কিছু কম অপস সহ বিকল্প 22-বাইট সংস্করণ:

$&MY_Y_NaMa$=y&--1=1Ny
— DLosc
সূত্র
1

স্মাইলব্যাসিক, 164 152 148 140 বাইট

DeF M(X)DIM W[#R]WHILE""<X
INC w[ASC(x)]X[n]=""wEND
FOR F=e#TO--nOT-LEN(W)U=w[F]H=H||U&&U<MAx(W)neXT-!!!AASSS#&&Oxx||CCLL<<wIM#
RETURN!H
enD

35 টি বিভিন্ন অক্ষর, প্রতিটি 4 বার পুনরাবৃত্তি।

কোনও মন্তব্য ব্যবহার করা হয়নি (তবে প্রকাশের পরে neXT প্রকাশটি আসলে কখনই মূল্যায়ন হয় না)

উত্তরগুলি পরীক্ষা করার জন্য স্ক্রিপ্ট:

কোড স্নিপেট দেখান

— 12Me21
সূত্র
1

রেটিনা 0.8.2 , 168 90 বাইট

মিথ্যা হলে আউটপুট খালি হবে, বা সত্য হলে খালি হবে।

***???;;;;```!!$$$$MMMMOOOO..1111ssss222{{{{\^^^^

s;{O`.
M!*\`^((.)\2(?!\2))*$
(.)(?!\1)

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

মূল প্রোগ্রাম (39 বাইট)

s;{O`.
M!*\`^((.)\2(?!\2))*$
(.)(?!\1)

ব্যাখ্যা

পুরো কোর প্রোগ্রামটি নিঃশব্দে রয়েছে। প্রথম পর্যায়ে ইনপুটটি বাছাই করে। দ্বিতীয় স্তরের বর্তমান স্ট্রিংটি মুদ্রণ করবে যদি এতে বিভিন্ন অক্ষরের ধারাবাহিক যুগল থাকে। তৃতীয় পর্যায়ে প্রতিটি চরিত্রের শেষ ঘটনাটি সরিয়ে দেয় (স্ট্রিংয়ের প্রতিটি অক্ষরের একটি অপসারণ)।

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

— mbomb007
সূত্র
ভাল, আমার উত্তরটি সংক্ষিপ্ত, তবে আমি নিশ্চিত নই যে আউটপুট হিসাবে এটি 0/1 এর জন্য স্থির করে রাখা ভাল les
— FryAmTheEggman
@ ফ্রাইআম দ্য এজিগম্যান আমি একত্রে একই দৈর্ঘ্যের চরিত্রের গ্রুপগুলির সাথে মেলে একটি বিশুদ্ধ রেইগেক্স সমাধানের সন্ধান করছিলাম, তবে আমি এটি বের করতে পারি না।
— mbomb007
@ ফ্রাইআম দ্য এজিজিম্যান একটি বড় উন্নতি করেছে! আপনার কাছে যা ছিল তা আমি সত্যিই ব্যবহার করি নি, তবে আমি আরও ভাল পদ্ধতিটি ভাবার চেষ্টা শুরু করেছিলাম।
— mbomb007
সুন্দরভাবে সম্পন্ন! আমার প্রোগ্রামটি দেখে মনে হচ্ছে আমি যথেষ্ট ভাবিনি, তবে কমপক্ষে আপনি এর চেয়ে ভাল একটি খুঁজে পেয়েছেন :)
— ফ্রাইআম দ্য এজিগম্যান
1

পাইথ, 30 বাইট

  "&8<MQSlqr{"&q1lJ{hMrSz8<1hJ

নেতৃস্থানীয় স্থান প্রয়োজন।

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

প্রকৃত প্রোগ্রাম ঠিক হয় &q1lJ{hMrSz8<1hJ। আমি কেবল স্ট্রিংটি চাপিয়েছি"&8<MQSlqr{" বৈষম্যমূলক করার জন্য । তবে স্ট্রিংটি নিজেই মুদ্রিত না হওয়ার জন্য আমাকে একটি স্থান যুক্ত করতে হয়েছিল, তাই আমি 2 টি স্পেস যুক্ত করেছি।

&q1lJ{hMrSz8<1hJ

 q1l                (1 == len(
    J{                  J = deduplicate(
      hM                  map(lambda a: a[0],
        r  8                length_encode(
         Sz                   sorted(input())
                            )
                          )
                        )
                    )
&                     and
            <1hJ    (1 < J[0])

length_encode এখানে (r <any> 8 ) একটি ক্রম নেয় এবং একই অক্ষরের প্রতিটি রানের দৈর্ঘ্য আউটপুট করে ex "aaabbcc"হয়ে [[3, "a"], [2, "b"], [2, "c"]]।

সুতরাং এটি ইনপুট নেয়, দৈর্ঘ্য এনকোডে রাখার জন্য এটি সাজায় এবং ফলাফলের তালিকার প্রতিটি তালিকার প্রথম উপাদান নেয় (যেমন পূর্ববর্তী উদাহরণটি হয়ে যাবে) [3, 2, 2] )। এটি কতবার অক্ষর ঘটে তার একটি গণনা দেয়। তারপরে এটি অনুলিপি করা (পূর্ববর্তী উদাহরণটি হয়ে যাবে)[3, 2] ), এবং জে সেট করা আছে।

তারপরে এটি পরীক্ষা করে যে দৈর্ঘ্যটি 1 হয়, অর্থাত্ একটি চরিত্রের সংখ্যার সংখ্যা মাত্র 1 টি এবং যদি এটি> 1, অর্থাৎ> = 2 হয়।

প্রতিস্থাপনের জন্য একটি অন্তর্নির্মিত থাকতে পারে rSz8বা hMrSz8আমি এটি খুঁজে পাচ্ছি না।

— আর কে।
সূত্র
1

সি (জিসিসি) , 153 বাইট

f(h,a,c,f){{{{{{{char*o=f=h,*r;for(a=!h;*o;o++){for(c=!h,r=h;*r;c+=!(*r++^*o)){}f*=!!(c^!!h)*(!a+!(a^c));a=c;}(a^c^c^f^f^h)+o,a+r,o,o,+h^*r;(a=f);}}}}}}}

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

সত্যের মান হিসাবে স্ট্রিংয়ের ঠিকানা এবং মিথ্যা হিসাবে শূন্য প্রদান করে।

f(
h,                              Address of string.
a,                              # instances of previous character
c,                              # instances of current character
f                               Return value
){{{{{{{                        
char*o=f=h,*r;                  Point o to string, while giving f a non-zero value.
for(a=!h;*o;o++){               Set previous char count to 0, and then traverse the string.
for(c=!h,r=h;*r;                Set current char count to 0 and r to string,
                                and start counting instances of current character.
c+=!(*r++^*o))                  Add to counter if current character matches.
{}                              Lower the amount of semi-colons
f*=                             Multiply (AND) return value with:
   !!(c^!!h)                    Is current count not 1? (Must be 2 or above.)
            *(!a+!(a^c));       AND, is previous count valid (meaning this is not the first
                                character counted), and matches current count?
a=c;}                           Previous count = current count.
(a^c^c^f^f^h)+o,a+r,o,o,+h^*r;  Spend surplus characters to make source code valid.
(a=f);}}}}}}}                   Return value.
— gastropner
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.