শব্দগুলি তাদের রূপরেখা সংরক্ষণ করার সময় স্ক্যাম্বল করুন

44

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

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

  1. স্ক্র্যাম্বলিং অবশ্যই (ছদ্ম) এলোমেলো হতে হবে।

  2. একটি শব্দ ল্যাটিন অক্ষরের একটি ক্রম, এ থ্রি জেড এর মাধ্যমে।

  3. কেবলমাত্র প্রাথমিক বর্ণগুলি বড় হাতের অক্ষরে থাকবে।

  4. প্রথম এবং শেষ বর্ণগুলি অবশ্যই নিরবচ্ছিন্ন থাকতে হবে।

  5. যখন স্ক্র্যাম্বলিং হয়, কেবল নিম্নলিখিত গ্রুপগুলির মধ্যে একটিতে অক্ষরগুলি স্থানগুলি বিনিময় করতে পারে:

    1. acemnorsuvwxz

    2. bdfhkl

    3. gpqy

    4. it

    5. j (জায়গায় থাকে)

উদাহরণ

Srcmable কব্জি যখন তাদের oeiltnus psrrnveieg হয়

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

  1. Smncrbliag অবশ্যই (pusedo) রন্ডম হতে হবে।

  2. একটি কুঁচকে লাতিন ক্রের্যাট্যাক্সের একটি পৃথক স্থান, একটি থুরোগ জেড is

  3. কেবলমাত্র প্রাথমিক লিটিটিই বড় আকারের হবে।

  4. Fisrt এবং lsat লেট্রেস অবশ্যই uctoenhud থাকতে হবে।

  5. যখন সরলকিম্বিং, কেবলমাত্র একটি চিঠি উইলটিনইওগ গর্পস প্লেকগুলিকে এক্সচেঞ্জ করতে পারে:

    1. aneusvrowxmcz

    2. bhkfdl

    3. gqpy

    4. it

    5. j (plcae থাকে)

Emxaple

code-golf  string  random  permutations 
— আদম
সূত্র
thযদিও এটি অনেকে লেখেন না তার চেয়ে খাটো হওয়ার কথা ।
— লিকি নুন
@ লিক্যনুন আমি জানি, তবে আপনি কি tগ্রুপ 2 থেকে সরিয়ে দেওয়ার পরামর্শ দিচ্ছেন ? অথবা tসাথে একটি গ্রুপ 4 করা i?
— অ্যাডম
পরেরটি ভাল হবে।
— লিকি নুন
রানটাইমটি কি তাত্ত্বিকভাবে সীমাহীন হতে পারে? (যেমন কিছু ঠিক না হওয়া পর্যন্ত এলোমেলো চেষ্টা করা হয়)
— সার্জে বোর্শ
1
printable/ patnirlbeবেশ পঠনযোগ্য নয়। আমি মনে করি i/ tঅদলবদলকে দোষ দেওয়া যায়। হুম ... paintrlbeনা এটিও সাহায্য করেনি। এটি সম্ভবত pr/ paঅদলবদল, তারপর। রূপরেখা বজায় রাখে, কিন্তু আমি মনে করে আমি শব্দার্থগতভাবে (?) 1 টি অক্ষর হিসেবে "জনসংযোগ" এবং "PA" পড়ুন। prtnialbeঅই হ্যাঁ. এটা এটা করেছে। নিশ্চিত নই যে আমি যদিও অ্যালগরিদমকে ঠিক করতে পারি।
— ড্রাকো 18

উত্তর:

9

জেলি , 80 74 বাইট

-2 বাইট থেকে সরানোর czar + vex + mow + sunমাধ্যমে czar + vexes + unmown(পুনরাবৃত্তি হওয়া eও nগুলি কোনও সমস্যা নয়)
-1 বাইট ব্যবহার Tịনা করে ȦÐf
-1 বাইট ব্যবহার Œle€Øaনা করে -2 বাইট ব্যবহার i@€ØB>⁵
করে বিন্যাসটি সামান্য পুনর্নির্মাণ করে

Tị
TẊị⁹ż@œp
e€ç⁸F
W;“HọƊṘ€.`]HɲøƁḤ0ẉlfrøj⁷»Ḳ¤ç/
Ḣ,ṪjÇḟ0
Œle€Øað¬œpÇ€ÑżœpÑ¥

একটি সম্পূর্ণ প্রোগ্রাম একটি অক্ষর তালিকা (বা পাইথন ফর্ম্যাট স্ট্রিং) গ্রহণ করে, যা স্ক্র্যাম্বলিংয়ের ফলাফল মুদ্রণ করে।

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

জেলির পক্ষে এখানে বিপুল পরিমাণে অসুবিধা মনে হয় (তা হয় বা আমি কোনও কৌশল মিস করেছি যা ঘটেছিল!) এটি অবশ্যই রেটিনা (কোনও এলোমেলো কার্যকারিতা নয়) বা 05 এবি 1 এর মতো আরও ভাল স্ট্রিং ম্যানিপুলেশন সহ ভাষাগুলি দ্বারা প্রহার করা হবে ।

কিভাবে?

Tị - Link 1, get truthy items: list a
T  - truthy indexes of a
 ị - index into a

TẊị⁹ż@œp - Link 2, selective shuffle: list a, list b
T        - truthy indexes of a (those indexes that may be shuffled in b)
 Ẋ       - random shuffle
   ⁹     - link's right argument, b
  ị      - index into (gets the shuffled values)
      œp - partition b at truthy indexes of a
    ż@   - zip with reversed @rguments (place shuffled values - yields a list of lists)

e€ç⁸F - Link 3, value selective shuffle: list a, list b
e€    - c exists in b? for €ach c in a (1s where b has shuffle-able characters, else 0s)
   ⁸  - link's left argument, a
  ç   - call the last link (2) as a dyad
    F - flatten the result (from the yielded list of lists to one list)

W;“HọƊṘ€.`]HɲøƁḤ0ẉlfrøj⁷»Ḳ¤ç/ - Link 4, perform all shuffles on a word's innards: list x
W                             - wrap x in a list
                          ¤   - nilad followed by link(s) as a nilad:
  “HọƊṘ€.`]HɲøƁḤ0ẉlfrøj⁷»     -   compression of s(bdfhkl)+d( czar)+d(vexes)+d(unmown)+s( gpqy)+d( ti)
                              -     where d() looks up a word in Jelly's dictionary and s() adds a string to the compressed output.
                         Ḳ    -   split on spaces: ["bdfhkl","czarvexesunmown","gpqy","ti"]
                           ç/ - reduce by last link (3) as a dyad (shuffles by each in turn)

Ḣ,ṪjÇḟ0 - Link 5, shuffle a word: list w
Ḣ       - head w (yields the leftmost character and modifies w)
  Ṫ     - tail w (yields the rightmost character and modifies w)
 ,      - pair
        -   Note: head and tail yield 0 when w is empty, so ['a'] -> ["a",0] and [] -> [0,0]
    Ç   - call the last link (4) as a monad (with the modified w)
   j    - join
     ḟ0 - filter discard zeros (thus single or zero letter words pass through unchanged)

Œle€Øað¬œpÇ€ÑżœpÑ¥ - Main link: list s
Œl                 - convert s to lowercase, say t
    Øa             - lowercase alphabet, say a
  e€               - c exists in a? for €ach c in t
      ð            - dyadic chain separation (call that u)
       ¬           - not (vectorises across u), say v
        œp         - partition s at truthy indexes of v (extract words, plus empty lists from within strings of non-alphabetic characters)
          Ç€       - call the last link (5) as a monad for €ach (shuffle their innards)
            Ñ      - call the next link (1) as a monad (only keep the actual words)
                 ¥ - last two links as a dyad:
              œp   -   partition s at truthy indexes of u (get the non-words, plus empty lists from within strings of alphabetic characters)
                Ñ  -   call the next link (1) as a monad (only keep actual non-words)
             ż     - zip together
                   - implicit print
— জোনাথন অ্যালান
সূত্র
এটি আসলে আমার চেয়ে বেশি শক্ত।
— লিকি নুন
@ লেকিউন ওয়েপ করলাম এটি সাথে আঁকতে আমার 10 মিনিটেরও বেশি সময় লেগেছে।
— জোনাথন অ্যালান
1
@ জোনাথান অ্যালান হ্যাঁ, এটি বহু যুগ ধরে ছিল, এবং সম্ভবত পরবর্তী প্রকাশের অংশ হতে চলেছে, কারণ এটি আমাকে বহুবার বক করছে।
— মার্টিন এেন্ডার
1
czar + vex + mow + sun‽
— অ্যাডম
3
@ অ্যাডম অভিধানের ফর্মালিউশনগুলি দেখুন acemnorsuvwxz। আমি কিছু সময়ে মন্তব্য কোড লিখব।
— জোনাথন অ্যালান
5

পিএইচপি, 278 বাইট

<?=preg_replace_callback("#\pL\K(\pL+)(?=\pL)#",function($t){preg_match_all("#([^bdf-lpqty])|([bdfhkl])|([gpqy])|([it])|(j)#",$t[0],$p);foreach($p as$v){$k++?$c=array_keys($n=array_filter($v)):$o=[];!$n?:shuffle($n)&&$o+=array_combine($c,$n);}ksort($o);return join($o);},$argn);

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

সম্প্রসারিত 

echo preg_replace_callback("#\pL\K(\pL+)(?=\pL)#" # patter \pL is shorter as [a-z]
,function($t){  # replacement function beginning
  preg_match_all("#([^bdf-lpqty])|([bdfhkl])|([gpqy])|([it])|(j)#",$t[0],$p); # makes groups with the regex. group 0 is the whole substring
  foreach($p as$v){ # loop through groups
    $k++?$c=array_keys($n=array_filter($v)):$o=[]; # group 0 make new empty replacement array in the other case filter the group remove empty values. 
    #You gain an array with the keys as position in the substring and the values
    #store the key array and the values array
    !$n?:shuffle($n)&&$o+=array_combine($c,$n); 
    #if values shuffle the values and make a new array with the keys and the shuffled values and merge the new array to the replacement array
  }
  ksort($o); # sort the replacement array ascending positions 
  return join($o); # return the replacement as string
},$argn);

ক্রিয়াকলাপ

array_combine

array_filter

array_keys

ksort

preg_replace_callback

অদলবদল

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

পাইথ , 79 বাইট

sm?td++hduuXNhTeTC,f@@GTHUG.S@HGG+-GJ."by❤jã~léܺ"cJ\jPtdedd:jb.z"([A-Za-z]+)"3

যেখানে ❤ইউ + 0018।

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

নমুনা

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

  1. স্ক্যাম্র্লবিং অবশ্যই (puesdo) rnadom হতে হবে।

  2. একটি শব্দ হ'ল ল্যাটিন চিত্রাধ্যক্ষগুলির একটি যথাযথ, একটি থুওর্গ জেড।

  3. কেবল আইয়াইটিনল লেটার্সই বড় হয়ে উঠবে।

  4. প্রথম এবং শেষ লেট্রেস মিসট না থাকুক।

  5. যখন স্র্যাঙ্কব্লিম্গ, কেবলমাত্র লেট্রেস উইলহিটন ফলনভিওগ গর্পগুলির মধ্যে একটিতে প্লিকাসকে বাড়িয়ে দিতে পারে:

    1. amsuvrcnoxewz

    2. bhfkdl

    3. gpqy

    4. it

    5. j (জায়গায় থাকে)

— ফুটো নুন
সূত্র
আপনি \pLপরিবর্তে সঙ্গে সংরক্ষণ করতে পারবেন না [A-Za-z]?
— অ্যাডম
@ অ্যাডম কী \pL?
— লিকি নুন
এল ইটার হওয়ার পি রোপার্টি সহ যে কোনও চরিত্র ।
— অ্যাডম
আমার মনে হয় না এটি এখানে কাজ করে ...
— লিকি নুন
না \wযথেষ্ট হবে?
— সার্জে বোর্শ
5

জাভাস্ক্রিপ্ট 176 বাইট

t.replace(/\B(\w+)\B/g,b=>{return[/[acemnorsuvwxz]/g,/[bdfhkl]/g,/[gpqy]/g,/[it]/g].forEach(d=>{g=b.match(d),b=b.replace(d,c=>{return g.splice(Math.random()*g.length,1)})}),b})

পদ্ধতি:

  1. 1 ই রিপ্লেস এফএন /\B(\w+)\B/gব্যবহার করে প্রতিটি শব্দের কেন্দ্রে ( ) পুনঃপ্রবিবর্তিত হয় ।

  2. প্রথম প্রতিস্থাপন fn প্রতিটি অক্ষর-গোষ্ঠী ( /[bdfkhl/g, /[gqpy]/g, etc..) এর জন্য RegExp এর একটি অ্যারের পুনরাবৃত্তি করে ।

  3. প্রতিটি পুনরাবৃত্তি শব্দের কেন্দ্রের অক্ষরের একটি অস্থায়ী বিন্যাস বর্তমান অক্ষর-গোষ্ঠীতে উপস্থিত হয়।

  4. প্রতিটি পুনরাবৃত্তির পরে ২ য় প্রতিস্থাপন fn ব্যবহার করে পুরো শব্দ কেন্দ্রের উপর পুনরাবৃত্তি করতে বর্তমান চিঠি-গোষ্ঠীর RegExp ব্যবহার করে।

  5. ২ য় প্রতিস্থাপন fn এলোমেলোভাবে টেম্প অ্যারে বিভক্ত করে, একটি এলোমেলো অক্ষর মুছে ফেলা এবং এটি ফিরিয়ে দেয়।

ডেমো:

এটি জেএসফিডেলে চালান: https://jsfiddle.net/CookieJon/bnpznb7r/

— অসমান
সূত্র
পিপিসিজিতে আপনাকে স্বাগতম। আশ্চর্যজনক প্রথম উত্তর। যাইহোক, আমি মনে করি আপনার অঙ্কগুলি এবং আন্ডারস্কোর বাদ দেওয়ার \pL(\pL+)\pLচেয়ে প্রয়োজন \B(\w+)\B।
— অ্যাডম
আহ, ধন্যবাদ! রেজেক্স অবশ্যই আমার ব্যাগ নয় (প্রতিটি সময় আমি এটি ব্যবহার করার সময় রেফারেন্সটি সন্ধান করতে হবে!) আমি 3 টি অতিরিক্ত অক্ষর গ্রাস করতে পারি ... শীঘ্রই আমার উত্তরটি আপডেট করব আবার ধন্যবাদ ধন্যবাদ। :-)
— বম্পি
1
অবিশ্বাস্য প্রথম উত্তর! :) উপরের @ অ্যাডাম সংশোধন সহ আপনাকে 155 বাইটে নামিয়ে আনতে আপনার জন্য কয়েকটি দ্রুত উন্নতি হয়েছে: টি => টি.রেপ্লেস (/ \ বি [আজ]] + \ বি / জিআই, বি => ([/ [এসেমনর্সউউউক্সজ ] / G, / [bdfhkl] / G, / [gpqy] / G, / [এটা] / ছ] .map (ঘ => খ = b.replace (ঘ, গ => ছ। স্প্লাইস (নতুন তারিখ% g.length, 1), g = b.match (d)), খ))
— শেগি
@ শেগি আমার ধারণা b=>[...].map(...)&&bঅন্য একটি বাইট সংরক্ষণ করে। এছাড়াও আমি নিশ্চিত না যে আপনার iপ্রয়োজনীয়।
— নীল
@ অ্যাডাম যদি তার শব্দের সংজ্ঞা সাথে কঠোরভাবে পিক হতে চলেছে তবে আপনাকে t.replace(/[A-Za-z]([a-z]+)(?=[a-z])/g,(w,b)=>...w[0]+b...)বা এরকম কিছু ব্যবহার করতে হবে ।
— নিল
2

সি, 453, 356 369 বাইট

#define F for
#define M rand()%s+1+q
char a[256],*b=" acemnorsuvwxz\1bdfhkl\1gpqy\1it\1j";g(c,t)char*c,*t;{static int i,j,k,w,v,n,q,s,r;r=-1;if(c&&t){strcpy(c,t);if(!k)F(j=i=k=1;b[i];++i)b[i]-1?(a[b[i]]=j):++j;F(r=i=0;c[i];){F(;isspace(c[i]);++i);F(q=i;!isspace(c[i])&&c[i];++i);F(s=v=i-q-2;--v>0;)if(a[c[j=M]]==a[c[w=M]]&&a[c[j]])n=c[j],c[j]=c[w],c[w]=n;}}return r;}

মন্তব্য সঙ্গে ungolf

// Input in the arg "t" result in the arg "c"
// NB the memory pointed from c has to be >= memory pointed from t
//    the char is 8 bit
#define F for
#define M rand()%s+1+q
char a[256], *b=" acemnorsuvwxz\1bdfhkl\1gpqy\1it\1j";
   g(c,t)char*c,*t;
   {static int i,j,k,w,v,n,q,s,r;
    r=-1;
    if(c&&t)
      {strcpy(c,t);                         // copy the string in the result space
       if(!k)
         F(j=i=k=1;b[i];++i)
             b[i]-1?(a[b[i]]=j):++j;        // ini [possible because at start k=0]
       F(r=i=0;c[i];)
         {F(;isspace(c[i]);++i);            //skip spaces
                                            // the start q the end+1 i
          F(q=i;!isspace(c[i])&&c[i];++i);  //skip word
          F(s=v=i-q-2;--v>0;)               //loop for swap letters of the same set
            if(a[c[j=M]]==a[c[w=M]]&&a[c[j]])
                n=c[j],c[j]=c[w],c[w]=n;
         }
      }
   return r;
  }


#include <stdio.h>
#define G(x,y) if(x)goto y
main()
{char a[256],r[256];
l1:
 gets(a);// i would know the string lenght<256
 g(r,a);
 printf("%s\n",r);
 G(*a,l1);
}
— RosLuP
সূত্র
1

পাইথন 3.6, 349 340 বাইট

from itertools import *
from random import *
import re
def S(s):
    C=lambda c:len(list(takewhile(lambda x:c not in x,('j','it','gqpy','bhkfdl'))));L=[];B=[[]for i in range(5)]
    for l in s:c=C(l);L+=[c];B[c]+=[l];shuffle(B[c])
    return''.join(B[n].pop()for n in L)
A=lambda t:re.sub('[A-Za-z]{3,}',lambda x:x[0][0]+S(x[0][1:][:-1])+x[0][-1],t)

ট্যাব সহ সূচিত। ফাংশনটির নামকরণ করা হয়েছে A। এটি নৃশংস শক্তি ব্যবহার করে না, ওপেন যেমনটি বলেছিল, রানটাইমটি হ'ল নির্বিচারবাদী।

— সার্জে বোর্স
সূত্র
1

গণিত 232 বাইট

StringReplace[#,x:Repeated[WordCharacter,{2,∞}]:>""<>(s=StringTake)[x,{i,i}~Table~{i,StringLength@x}/.Flatten[Thread[#->RandomSample@#]&/@(StringPosition[x~s~{2,-2},#]+1&/@Characters@{"acemnorsuvwxz","bdfhkl","gpqy","it","j"})]]]&

মূল ধারণাটি 4 স্বতন্ত্র চরিত্রের গোষ্ঠীগুলির সাথে সম্পর্কিত সাবসেটগুলিকে অনুমতি দেওয়া। সম্ভবত উন্নতির জন্য জায়গা।

— কেলি লোদার
সূত্র
1

সি, 306 282 বাইট

c,o,d,e,g;l(char*f){char*s[]={"aneusvrowxmcz","bhkfdl","gqpy","it",0},**h,*i,*t;for(i=f;*i;){if(isalpha(*i)){t=i;while(*i&&isalpha(*i))i++;e=i-t-2;for(h=s;*h&&e;*h++){for(c=999;--c;){d=1+rand()%e,o=1+rand()%e;if(strchr(*h,t[d])&&strchr(*h,t[o]))g=t[d],t[d]=t[o],t[o]=g;}}}else++i;}}

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

Ungolfed:

int func(char*p) 
{
    char *groups[] = {"aneusvrowxmcz","bhkfdl","gqpy","it",0}, **g, *s, *t;
    int n,r,i,l,o;

    for (s = p; *s;)
    {
        if (isalpha(*s))
        {
            t = s;
            while (*s && isalpha(*s))
                s++;
            // start scrambling
            l = s - t - 2;
            for(g=groups; *g && l; *g++)
            {
                for(n=999;--n;)
                {
                    i = 1 + rand() % l;
                    r = 1 + rand() % l;
                    if (strchr(*g, t[i]) && strchr(*g, t[r]))
                    {
                        o=t[i];
                        t[i]=t[r];
                        t[r]=o;
                    }
                }
            }
            // end scrambling
        }
        else 
            s++;
    }
}
— জোহান ডু টোয়েট
সূত্র
আপনি কেন একটি কথায় 999 অদলবদল করতে চান? আপনি কি জানেন যে একটি চরের একটি শব্দের l = -1 রয়েছে এবং এর সম্ভবত এটির অর্থ এটি 1+ র্যান্ড ()% -1 ব্যবহার করে 999 সম্ভাব্য অদলবদল করা শুরু করে তাই 2 গিগা স্মৃতিতে র্যান্ডম লিখুন ... তবে সম্ভব আমি দেখতে পাচ্ছি এটি ভুল ....
— রোজলুপ
দুর্ভাগ্যক্রমে 999 এর ব্যবহার সম্পর্কিত কোনও যাদু নেই It's এটি 1000 এর চেয়ে কম 1 বাইট :)
— জোহান ডু টোইট
জিসিসি-তে এটি র্যান্ড ()% (- 1) মনে হয় 0 প্রথম চেষ্টা করার পরে 0 বার ফিরে আসে। তাই সম্ভব এলোমেলো 2 গিগা জায়গার কোনও অদলবদল ...
— ইতিপূর্বে
@ রোসলুপ, আমি দুঃখিত তবে আপনি যা বলছেন তা আমি অনুসরণ করি না
— জোহান ডু টোইট
1

জাভাস্ক্রিপ্ট (ES6), 380 327 311 294 বাইট

( 298 282 265 বাইটস বিধি বাদে)

দরকারী টিপসের জন্য @ শ্যাগি ধন্যবাদ!

((b,d)=>b.replace(/\B[a-z]+\B/gi,f=>(g=>(g.map(j=>(h=d.slice(0,~(rind=d.indexOf(j))?rind:-1),~rind?h.split`,`.length-1:-1)).map((j,k,l,m=[])=>{l.map((n,o)=>n==j?m.push(o):0),sub=m[new Date%(m.length-1)]||k,tmp=g[sub],g[sub]=g[k],g[k]=tmp}),g.join``))([...f])))(s,"aneusvrowxmcz,bhkfdl,gqpy,it");


var f = ((b,d)=>b.replace(/\B[a-z]+\B/gi,f=>(g=>(g.map(j=>(h=d.slice(0,~(rind=d.indexOf(j))?rind:-1),~rind?h.split`,`.length-1:-1)).map((j,k,l,m=[])=>{l.map((n,o)=>n==j?m.push(o):0),sub=m[new Date%(m.length-1)]||k,tmp=g[sub],g[sub]=g[k],g[k]=tmp}),g.join``))([...f])))

var s="Let there be scrambling";
console.log(s);
console.log(f(s,"aneusvrowxmcz,bhkfdl,gqpy,it"))

s="It is well known that a text can still be read while the innards of its words have been scrambled, as long as their first and last letters plus their overall outlines remain constant. Given a printable Ascii+Newline text, scramble each word according to these rules";
console.log(s);
console.log(f(s,"aneusvrowxmcz,bhkfdl,gqpy,it"))
স্নিপেট প্রসারিত করুন

ফাংশন এফ যে কোনও ধরণের স্ট্রিং (একক শব্দ, একাধিক শব্দ, এতে চিহ্ন সহ একাধিক শব্দ - যা এটি শব্দ-ভাঙ্গা হিসাবে ব্যাখ্যা করে) এবং একটি অ্যারে কমা দ্বারা পৃথক করা কোনও দৈর্ঘ্যের "নিয়ম" এর একটি স্ট্রিং গ্রহণ করে।

আপনার প্রশ্নের ক্ষেত্রে, বিধিগুলির এই অ্যারেটি হবে ["aneusvrowxmcz", "bhkfdl", "gqpy", "it"] "aneusvrowxmcz,bhkfdl,gqpy,it"

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

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

মানব-পঠনযোগ্য অ-অ-বিভক্ত কোড:

((txt,rules)=>txt.replace(/\B[a-z]+\B/gi,wo=>((w=>(w.map(c=>(h=rules.slice(0, ~(rind=rules.indexOf(c))?rind:-1),~rind?(h.split`,`.length-1):-1)).map((e,i,arr,a=[])=>{
    arr.map((x,i)=>(x==e)?a.push(i):0),
    sub=a[new Date%(a.length-1)]||i,
    tmp=w[sub],
    w[sub]=w[i],
    w[i]=tmp
}),w.join``))([...wo]))))(str, "aneusvrowxmcz,bhkfdl,gqpy,it")
— Hankrecords
সূত্র
1
ওপি বিধিগুলিকে বাইট কাউন্টে অন্তর্ভুক্ত করতে হবে। দ্বারা মে , আমি বোঝানো করার একটি সুযোগ ।
— অ্যাডম
1
পিপিসিজিতে আপনাকে স্বাগতম :) আপনি অবশ্যই এ থেকে অনেক কিছু গল্ফ করতে পারেন ।
— শেগি
1
আমি এটি আপনার জন্য গল্ফ করার চেষ্টা করতে যাচ্ছিলাম তবে এটি দিয়ে কত কিছু করা যায় তা প্রদত্ত, আমি সময় নষ্ট করেছিলাম পরিবর্তে আমি আপনাকে এখানে এবং এখানে আপনাকে শুরু করতে সহায়তা করার জন্য নির্দেশ করব ।
— শেগি
1
কয়েকটি দ্রুত পয়েন্টার, যদিও: 01) সমস্ত varগুলি একটি letএস থেকে পরিত্রাণ পান । 02) এটি পুনরাবৃত্ত ফাংশন f=না হলে আপনার বাইট গণনায় ভেরিয়েবল ডিক্লেয়ারেশন ( ) অন্তর্ভুক্ত করার দরকার নেই । 03) কোনও ফাংশনে 2 টি পরামিতি ( b=>d=>পরিবর্তে (b,d)=>) থাকে তখন কার্চিং ব্যবহার করুন এবং আপনার ফাংশনটিকে কল করুন f(b)(d)। 04) আপনার iপতাকাটি রয়েছে তাই A-Zআপনার রেজেক্সে অন্তর্ভুক্ত করার দরকার নেই । 05) আপনি ব্যবহার করতে পারেন indexOfবা searchএকটি অ্যারের মধ্যে একটি স্ট্রিং উপর, এটা বিভাজন ছাড়া।
— শেগি
1
কিভাবে পরামর্শ 03 অক্ষর সংরক্ষণ করে? তারা আমার কাছে একই দেখাচ্ছে।
— স্টিভ বেনেট
0

ক্লোজার, 326 322 324 বাইট

আপডেট 1: প্রতিস্থাপিত (map(fn[[k v]]...)...)সঙ্গে(for[[k v]...]...)

আপডেট 2: স্থির রেজেক্স, ইত্যাদির \pLপরিবর্তে ব্যবহার করে\w

#(let[G(zipmap"bdfhklgpqyitj""0000001111223")](apply str(flatten(interleave(for[v(re-seq #"\pL+"%)w[(rest(butlast v))]W[(into{}(for[[k v](group-by G w)][k(shuffle v)]))]R[(rest(reductions(fn[r i](merge-with + r{(G i)1})){}w))]][(first v)(map(fn[c r](nth(W(G c))(-(r(G c))1)))w R)(if(second v)(last v))])(re-seq #"\PL+"%)))))

আমি আরও ছোট কিছু দেখার জন্য অপেক্ষা করছি কয়েকটি উদাহরণ সহ পূর্ববর্তী সংস্কৃত সংস্করণটি রান করে:

(def f #(let[G(zipmap"bdfhklgpqyitj""0000001111223")] ; Create groups, the longest "acemnorsuvwxz" goes to an implicit group nil
          (apply str(flatten(interleave
                              (for[v (re-seq #"\w+"%)                                          ; Iterate over words
                                   w [(rest(butlast v))]                                       ; This holds the middle part
                                   W [(into{}(map(fn[[k v]][k(shuffle v)])(group-by G w)))]    ; Create shuffled groups
                                   R [(rest(reductions(fn[r i](merge-with + r{(G i)1})){}w))]] ; Calculate cumulative sum of group items, used to look-up nth value from shuffled values
                               [(first v)                                     ; First character
                                (map(fn[g r](nth(W g)(-(r g)1)))(map G w)R)   ; Shuffled middle part
                                (if(>(count v)1)(last v))])                   ; Last character, unless the word is just a single character
                              (re-seq #"\W+"%)))))) ; Interleave with spaces, commas, newline etc.

(f "It is well known that a text can still be read while the innards of its words have been scrambled, as long as their first and last letters plus their overall outlines remain constant.\n")
;  "It is well known that a txet can sitll be read wlihe the irnands of its wrods hvae been seacmlbrd, as lnog as their fisrt and lsat letters plus their oavrell ontlieus rmaein cnontast.\n"
;  "It is well kwonn that a text can sitll be raed wlihe the innards of its wrods hvae been seramlbcd, as long as their fisrt and lsat lettres plus their oravell ouiltnes rmeain cnsatont.\n"
;  "It is well konwn that a text can still be read while the iarnnds of its words have been sraemlbcd, as lnog as their first and lsat lrttees plus their oaevrll ontlieus remain canntsot.\n"
— NikoNyrh
সূত্র
আমি মনে করি আপনার যা দরকার \pL+এবং \PL+বদলে \w+এবং \W+সংখ্যার এবং আন্ডারস্কোর বাদ দেওয়ার।
— এডম
0

পার্ল 6 , 241 195 বাইট

-pকমান্ড-লাইন সুইচের জন্য +1 বাইট অন্তর্ভুক্ত ।

s:g/(<:L>)(<:L>+)(<:L>)/{$0}{[~]
$1.comb.pairs.classify({first
.value~~*,:k,/<[bdfhkl]>/,/<[gpqy]>/,/<[it]>/,/j/,!0}).values.map({$_».key
»=>«$_».value.pick(*)})».List.flat.sort».value}$2/;

Ungolfed:

s:g/(<:L>)(<:L>+)(<:L>)/{$0}{
    [~]
    $1.comb
    .pairs
    .classify({
        first .value ~~ *, :k,
            /<[bdfhkl]>/,
            /<[gpqy]>/,
            /<[it]>/,
            /j/,
            !0
    })
    .values
    .map({ $_».key »=>« $_».value.pick(*) })
    ».List
    .flat
    .sort
    ».value
}$2/;
— শন
সূত্র
আমি মনে করি আপনার অঙ্কগুলি এবং আন্ডারস্কোর বাদ দেওয়ার (\pL)(\pL+)(\pL)চেয়ে প্রয়োজন (\w)(\w+)(\w)।
— অ্যাডম
প্রকৃতপক্ষে \pLল্যাটিন অক্ষরের এজেডের অনুমোদিত ব্যাপ্তির বাইরে প্রচুর অক্ষর অন্তর্ভুক্ত। প্রয়োজনীয়তা আরও নির্ভুলভাবে প্রতিবিম্বিত করতে আমি আমার কোড আপডেট করেছি।
— শান
কোন চরিত্র? মনে রাখবেন ইনপুট প্রিন্টযোগ্য ASCII + নিউলাইনগুলিতে সীমাবদ্ধ।
— অ্যাডম
আহ, আমি এটা মিস করেছি। যদিও পার্ল in \pLএ বানান <:L>রয়েছে।
— শান
0

সি #, 438 394 380 374 বাইট

namespace System.Text.RegularExpressions{using Linq;s=>Regex.Replace(s,@"\p{L}(([gpqy])|(i|t)|(j)|([bdf-l])|([a-z]))*?[a-z]?\b",m=>{var a=m.Value.ToArray();for(int i=1,j;++i<7;){var c=m.Groups[i].Captures;var n=c.Cast<Capture>().Select(p=>p.Index-m.Index).ToList();foreach(Capture p in c){a[j=n[new Random().Next(n.Count)]]=p.Value[0];n.Remove(j);}}return new string(a);});}

@ মার্টিনএেন্ডারে to ধন্যবাদ 10 বাইট সংরক্ষণ করুন।

বিরক্তিকরভাবে, CaptureCollectionবাস্তবায়ন করে নাIEnumerable<T> এবং এজন্যই .Cast<Capture>()প্রয়োজন। আশা করি, আমি লিনক কোয়েরি এবং foreachলুপটি একত্রিত করতে পারি ।

আমি নিশ্চিত যে গল্ফ করা যেতে পারে এমন অনেক কিছুই আছে তবে এটি কাজ করতে আমার যথেষ্ট সময় লেগেছে ...

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

ফর্ম্যাট / সম্পূর্ণ সংস্করণ:

namespace System.Text.RegularExpressions
{
    using Linq;

    class P
    {
        static void Main()
        {
            Func<string, string> f = s =>
                Regex.Replace(s, @"\p{L}(([gpqy])|(i|t)|(j)|([bdf-l])|([a-z]))*?[a-z]?\b", m =>
                {
                    var a = m.Value.ToArray();

                    for (int i = 1, j; ++i < 7;)
                    {
                        var c = m.Groups[i].Captures;

                        var n = c.Cast<Capture>().Select(p => p.Index - m.Index).ToList();

                        foreach(Capture p in c)
                        {
                            a[j = n[new Random().Next(n.Count)]] = p.Value[0];
                            n.Remove(j);
                        }
                    }

                    return new string(a);
                });

            Console.WriteLine(f("Scramble words while preserving their outlines"));
            Console.ReadLine();
        }
    }
}
— TheLethalCoder
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.