वर्णमाला सूप के साथ एक कटोरा भरें


24

हम करने लगते हैं कभी नहीं मिल थक वर्णमाला से संबंधित चुनौतियों में से ...


विधि

दिया हुआ

  • पत्रों की एक स्ट्रिंग S, और
  • दो धनात्मक पूर्णांक M, N,

के पत्र के साथ एक वर्णमाला सूप का उत्पादन Sकब्जे यादृच्छिक पदों एक में आयताकार कटोरा आकार का M× N, फंसाया एक गैर वर्णमाला, गैर अंतरिक्ष चरित्र से कटोरा के रिम प्रतिनिधित्व करते हैं।

पत्रों द्वारा उपयोग नहीं की जाने वाली स्थितियों को रिक्त स्थान के रूप में प्रदर्शित किया जाना चाहिए। देखें नीचे दिए गए उदाहरणों

सशर्त नियम

  • आकार M× कटोरे Nके आंतरिक भाग को संदर्भित करता है । रिम सहित आकार M+2× है N+2
  • प्रत्येक पात्र को एक बार कटोरे में, एक अलग स्थिति में Sदिखाई देना चाहिए ; अर्थात्, एक वर्ण दूसरे को अधिलेखित नहीं कर सकता है।
  • S डुप्लिकेट हो सकते हैं । उदाहरण के लिए, यदि Sस्ट्रिंग है 'abcc', तो सूप में एक a, एक bऔर दो c(सभी अलग-अलग स्थिति में) होने चाहिए।
  • आदानों को पूरा करेगा प्रतिबंध M >= 1 , N >= 1, 1 <= length(S) <= M*N
  • कटोरे का रिम किसी भी गैर-वर्णानुक्रमिक, गैर-अंतरिक्ष वर्ण , प्रोग्राम रन और इनपुट मूल्यों के अनुरूप हो सकता है।
  • कटोरे में पत्र की स्थिति यादृच्छिक है, इसलिए परिणाम हर बार अलग-अलग हो सकता है क्योंकि कार्यक्रम उसी इनपुट के साथ चलाया जाता है।
  • इनपुट को देखते हुए, पत्र पदों के हर संभव सेट में एक गैर-शून्य संभावना होनी चाहिए । चूँकि यह कार्यक्रम के कुछ बोधों से जाँच नहीं किया जा सकता है, कृपया यह बताएं कि आपका कोड इसे कैसे पूरा करता है।
  • रिम के चारों ओर व्हाट्सएप का प्रमुख या अनुगामी होना अनुमत है।
  • Sशामिल होंगे केवल बड़े अक्षर हैं। यदि आप चाहें, तो आप केवल लोअरकेस अक्षर लेना चुन सकते हैं ।
  • इनपुट और आउटपुट हमेशा की तरह लचीले होते हैं । उदाहरण के लिए, आउटपुट न्यूलाइन, 2 डी कैरेक्टर एरे या लाइनों की सूची के साथ एक स्ट्रिंग हो सकता है।
  • प्रोग्राम या फ़ंक्शंस की अनुमति है, किसी भी प्रोग्रामिंग भाषा मेंमानक खामियों को मना किया जाता है।
  • बाइट्स में सबसे छोटा कोड जीतता है।

उदाहरण

इनपुट के रूप में दिखाए जाते हैं S, [M N], जहां Mपंक्तियों Nकी संख्या है और स्तंभों की संख्या है। चरित्र #का उपयोग रिम के लिए किया जाता है।

'O', [1 1]:

###
#O#
###

'HEY', [1 3]:

#####
#YHE#
#####


'HELLO', [4 11]:

#############
#  O        #
#         H #
#    LE     #
#   L       #
#############


'ADVNJSGHETILMVXERTYIOJKCVNCSF', [8 12]:

##############
#K  V  L   S #
# A   V  X H #
#T    M C    #
# I       O N#
#  YC        #
# G  I   R SE#
#   J      F #
#JT  D  V EN #
##############


'OOOOOOOOOOXXXXX', [13 31]:

#################################
#    X                          #
#                O              #
#                               #
#                  X            #
#                        O      #
#             X           O     #
#      O                        #
#         X                     #
#                        O      #
#       X                       #
#                    O          #
#  O      O      O              #
#                             O #
#################################


'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ', [11 41]

###########################################
#                                       JU#
#     Q         C M    G     R T U Y  H   #
#  KI          E   H    M   YO            #
#      V BW        I    JC                #
#     SV           D     P   B          U #
#           A     F    RF   J  KP E       #
#            E   N      TH        Z       #
#    N  BM  O     Q   I        AS N  WX   #
#   S     O  K       G L       P       Q  #
#Z     L T         R   L       A      F DD#
#      V   Y           WX   C       G XZ  #
###########################################


"कटोरे में पत्र स्थान यादृच्छिक हैं, [...]" <- क्या आपका मतलब यादृच्छिक हो सकता है या यादृच्छिक होना चाहिए? और क्या सभी पंक्तियों में हर समय एक ही नंबर का वर्ण हो सकता है?
इस्माईल मिगुएल

@IsmaelMiguel को चाहिए । और हर विन्यास को होने की चुनौती (चुनौती में कहा गया है) की एक गैरजरूरी संभावना होनी चाहिए। तो यह नियम-रेलवे-समान-लंबाई दृष्टिकोण
लुइस मेंडो

क्या रिम पूरे प्रोग्राम रन और इनपुट वैल्यू के अनुरूप हो सकता है, लेकिन कई गैर-अक्षरों का उपयोग करता है, उदाहरण के लिए ASCII आर्ट बॉर्डर के साथ |+-?
अड्म

@ Adám Hm मैं कहने जा रहा हूं कि नहीं, यह बहुत बड़ा बदलाव है
लुइस मेंडो

जवाबों:


13

05AB1E , 20 18 16 15 14 बाइट्स

*j.rS²ô2Føε8.ø

क्रम में तीन इनपुट लेता है: ऊंचाई, चौड़ाई, स्ट्रिंग। पात्रों की 2 डी सूची के रूप में आउटपुट। सीमा के रूप में
उपयोग 8करता है, लेकिन कोई भी अंक हो सकता है।

-1 बाइट @ ग्रीम को धन्यवाद ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें । (TIO में }}J»परिणाम को सुंदर रूप से प्रिंट करने के लिए पाद लेख में शामिल है; वास्तविक आउटपुट 2D वर्णों की सूची देखने के लिए इसे हटाने के लिए स्वतंत्र महसूस करें।)

स्पष्टीकरण:

*               # Multiply the (implicit) width and height inputs
 j              # Pad the (implicit) input-string with up to that amount of leading spaces,
                # so the total string-length is equal to that value
  .r            # Shuffle the characters in the string
    S           # Convert the string to a list of characters
                # (edge-case for the zip below with strings of size 1 with 1x1 dimensions)
     ²          # Push the width input again
      ô         # Split the list of characters into parts of that size
       2F       # Loop 2 times:
         ø      #  Zip/transpose the 2D list; swapping rows/columns
          ε     #  Inner map over each line:
           8.ø  #   And surround this line-list with a leading/trailing "8"
                # (after the loop, the result is output implicitly)

1
@LuisMendo मैं वास्तव में चुनौती केवल 3 मिनट पहले कहता हूं। ;) यह एक बहुत सीधे आगे कार्यान्वयन है। इसे यहां से नीचे गिराने की कोशिश करेंगे।
केविन क्रूज़सेन

1
बहुत अच्छा, मैंने सोचा नहीं था *j! यहां विरासत के लिए 13 , या आधुनिक के लिए एक बदसूरत 14 (एक 2 डी चरित्र सरणी आउटपुट)।
ग्रिमी

1
@ ग्रैमी १३-बायटर इनपुट के लिए विफल होता है 1,1,"O", इसलिए मुझे लगता है कि विरासत के लिए १४-बायटर होना चाहिए। हालांकि -1 के लिए धन्यवाद।
केविन क्रूज़सेन

7

एपीएल (Dyalog यूनिकोड) , 25 बाइट्स SBCS

'#',∘⌽∘⍉⍣4{⍵⍴⊃¨↓∘⍺¨?⍨×/⍵}

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

-22 धन्यवाद @ngn के लिए, -7 धन्यवाद @ngn और @ Adám के लिए

स्पष्टीकरण:

'#',∘⌽∘⍉⍣4{⍵⍴⊃¨↓∘⍺¨?⍨×/⍵}
          {            ⍵}  Function that generates the content
                            argument:  (width and height),  (string)
                     ×/    get the product
                   ?⍨      For each randomized elements
               ↓∘⍺¨        take the character in 
           ⍵⍴⊃¨            turn it back into a matrix of shape 
      4                 Then, 4 times, do these 3 things:
'#',                       - prepend a # to the axis
                          - reverse the columns
                          - swap columns and lines

एपीएल (Dyalog विस्तारित) , 21 बाइट्स SBCS

रिम के कोण अलग-अलग वर्ण हैं

{⌂disp⊂⍵⍴⊃¨↓∘⍺¨?⍨×/⍵}

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

बॉक्स प्रदर्शित करने के लिए dfn का उपयोग करना।


29: '#',∘⌽∘⍉⍣4⊢⍴∘(?⍨∘≢⊃¨⊂)↑⍨∘(×/) इसे ऑनलाइन आज़माएं!
आदम

28: {'#',∘⌽∘⍉⍣4⊢⍵⍴⍺\⍨(≢⍺)>?⍨×/⍵}(या के बजाय >अगर ⎕io=1)
ngn

वास्तव में, 27:'#',∘⌽∘⍉⍣4{⍵⍴⍺\⍨(≢⍺)>?⍨×/⍵}
ngn

3
25:'#',∘⌽∘⍉⍣4{⍵⍴⊃¨↓∘⍺¨?⍨×/⍵}
ngn


6

पायथन 3 , 110 बाइट्स

lambda s,m,n,r=['#']:[r+(n*r+[i for i,j in{*zip(s+m*n*' ',range(m*n))}]+n*r)[k*n:-~k*n]+r for k in range(m+2)]

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

एक setसमझ का उपयोग करके यादृच्छिक और एक 2 डी चरित्र सरणी देता है।


यादृच्छिक करने के लिए सेट समझ का अच्छा उपयोग। +1। लेकिन आपके कोड फ़ंक्शन के 'f' नाम पर निर्भर करते हैं। इसलिए मुझे लगता है कि
लंबोदर

1
@agtoever धन्यवाद! फ़ंक्शन पुनरावर्ती नहीं है, इसलिए यह अनाम हो सकता है। क्या आप f'{s:{m*n}}'भाग की बात कर रहे हैं ? क्योंकि यह एक स्वरूपित स्ट्रिंग के लिए वाक्यविन्यास है, जो संयोग से भी होता है f
जित्स

3
यह कोड कई मायनों में PEP 8 का उल्लंघन करता है।
क्रिस्टोफर ओहेल्सन

1
@ क्रिस्टोफर-ओह्सल्सन बिल्कुल!
Jitse

2
@ChristoferOhlsson कोड-गोल्फ, हाहा की दुनिया में आपका स्वागत है। ;) कोई टिप्पणी नहीं / डॉक्स जो भी; एकल चरित्र चर / तरीके बिना किसी (अनावश्यक) रिक्त स्थान / newlines; संभावित रूप से सैकड़ों संकलक-चेतावनियां जिन्हें हम आसानी से अनदेखा कर देते हैं; ओ (एन (एन)) से ओ (एन ^ एन) से बढ़ते प्रदर्शन; आदि अगर यह एक भी बाइट बचा सकता है, यह सब ठीक है और पूरी तरह से कोड-गोल्फिंग के लिए इसके लायक है। ;)
केविन क्रूज़सेन

5

बैश + कोरुटिल्स, 139 125 वर्ण

r=`printf %$3s@@|tr \  @`
echo $r
printf %$[$2*$3]s $1|fold -1|shuf|tr -d \\n|fold -$3|paste -d@ <(:) - <(:)|head -$2
echo $r

नमूना रन:

bash-5.0$ bash soup.sh HELLO 4 11
@@@@@@@@@@@@@
@  H        @
@      OE   @
@    L      @
@          L@
@@@@@@@@@@@@@

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

बैश + कोरुटिल्स + बॉक्स, 97 अक्षर

printf %$[$2*$3]s $1|fold -1|shuf|tr -d \\n|fold -$3|boxes -dsimple -s$[$3+2]x$[$2+2] -pa0 -itext

नमूना रन:

bash-5.0$ set -- HELLO 4 11

bash-5.0$ printf %$[$2*$3]s $1|fold -1|shuf|tr -d \\n|fold -$3|boxes -dsimple -s$[$3+2]x$[$2+2] -pa0 -itext
*************
* O   L  E  *
*      H    *
*           *
*     L     *
*************

इसे ऑनलाइन आज़माएं! (आंशिक रूप से, जैसा boxesकि TIO पर स्थापित नहीं है।)


5

जे , 30 29 बाइट्स

-1 बाइट जोनाह को धन्यवाद

'#'|.@|:@,^:4[$*/@[(?~@[{{.)]

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


1
क्योंकि TIO एक निश्चित यादृच्छिक बीज का उपयोग करता है। 9!:1]6!:9''ठीक करता है कि
Adám

2
वास्तव में जिस तरह से जीरो फिल का इस्तेमाल किया गया {.। 29 के लिए थोड़ा ट्विक करें'#'|.@|:@,^:4[$*/@[(?~@[{{.)] : इसे ऑनलाइन आज़माएं!
योना

1
@ जॉन धन्यवाद!
गैलेन इवानोव

5

पॉवरशेल , 163 111 93 बाइट्स

param($w,$h,$s)'#'*$w+-join($s|% *ht($w*$h)|% t*y|sort{Random})+'#'*$w-replace".{$w}",'#$0#
'

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

$wआईडी, $hआठ, ट्रिंग के रूप में इनपुट लेता है $s

#उपयुक्त $wमूर्ति की एक स्ट्रिंग का निर्माण करता है , स्ट्रिंग-जोड़ कुछ गणना के साथ, और फिर उसी #स्ट्रिंग को फिर से बनाता है । इनपुट लेने के साथ शुरू होता है गणना $string, और कर एक .padRig htअप करने के लिए $wद्वारा idth $hआठ लंबाई (यानी, एक स्ट्रिंग काफी लंबे समय के लिए पूरी तरह से आयताकार स्थान ले सकते हैं। हम तो परिवर्तित कि स्ट्रिंग toCharArra y, और sortयह Randomly। यही कारण है कि देता है हमें मिला-जुला मध्य भाग। अंत में, हम -replaceइसे बराबर $wमूर्ति के टुकड़े में रखते हैं, और उन टुकड़ों को #एस के साथ घेरते हैं ।

-52 AZTECCO -18 बाइट्स से प्रेरणा
के लिए धन्यवाद mazzy के लिए धन्यवाद


आपके पास 2 x यादृच्छिक (12) है जबकि JS में एक है, उसने M * N आकार भरने के लिए रिक्त स्थान जोड़े और क्रमबद्ध किया, उसके बाद भी आप '$' के लिए 21 का भुगतान दुर्भाग्य से करते हैं
AZTECCO

1
@AZTECCO प्रेरणा के लिए धन्यवाद!
AdmBorkBork 13

धन्यवाद @mazzy - -replaceबंटवारे और शामिल होने के बजाय बहुत चालाक ।
AdmBorkBork

4

जावास्क्रिप्ट (ईएस 7), 125 बाइट्स

एक स्ट्रिंग लौटाता है। 0फ्रेम चरित्र के रूप में उपयोग करता है ।

(s,h,w)=>(a=[...s.padEnd(w++*h++)].sort(_=>Math.random()-.5),g=x=>y+~h?(x%w&&y%h&&a.pop())+[`
`[x-w]]+g(x<w?x+1:!++y):a)(y=0)

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

टिप्पणी की गई

(s, h, w) => (               // s = string; h = height; w = width
  a =                        // build an array a[] consisting of:
    [...s.padEnd(w++ * h++)] //   all original characters in s padded with spaces for a
    .sort(_ =>               //   total length of w * h, in a random order
      Math.random() - .5     //   (this is not guaranteed to be uniform, but it is not
    ),                       //   required to be)
  g = x =>                   // g is a recursive function taking x:
    y + ~h ?                 //   if we haven't reached the end of the grid:
      ( x % w &&             //     if we're not located on a vertical border
        y % h &&             //     nor on a horizontal border,
        a.pop()              //     extract the last character from a[]
      ) +                    //     (otherwise, append '0')
      [`\n`[x - w]] +        //     if we've reached the end of the row, append a linefeed
      g(                     //     append the result of a recursive call:
        x < w ? x + 1 : !++y //       using either (x+1, y) or (0, y+1)
      )                      //     end of recursive call
    :                        //   else (end of grid):
      a                      //     a[] is now empty and can be used as an empty string
)(y = 0)                     // initial call to g with x = y = 0

4

एपीएल (Dyalog विस्तारित) , 23 बाइट्स SBCS

बेनामी tacit infix फ़ंक्शन। [M,N]बाएं तर्क के Sरूप में और सही तर्क के रूप में लेता है।

'#',∘⌽∘⍉⍣4⊣⍴×/⍛(?⍨⍤⊣⊇↑)

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

×/⍛() तर्कों के बीच निम्न फ़ंक्शन लागू करें, अपने उत्पाद के साथ बाएं तर्क की जगह:

दाईं ओर रिक्त स्थान के साथ पैडिंग से M× Nवर्ण  लेंS

 निम्नलिखित क्रम में फिर से व्यवस्थित करें:

?⍨⍤ फेरबदल सूचकांकों 1 के माध्यम से ...
 बाएं तर्क ( M× N)

आरनिम्नलिखित आकृति में

 बाएँ तर्क (यानी Mपंक्तियाँ और Nस्तंभ)

'#'⍣4 निम्न फ़ंक्शन को चार बार लागू करें, हर बार बाएं तर्क के रूप में हैश चरित्र के साथ:
∘⍉ सही तर्क को
∘⌽ दर्पण करें सही तर्क दर्पण के
,एक स्तंभ को बाईं ओर के कोने पर पहुंचाता है


4

PHP 7.4, 107 99 94 अक्षर

fn($s,$r,$c)=>_.chunk_split(($b=str_pad(_,$c,_)).str_shuffle(str_pad($s,$r*$c)),$c,"_
_").$b._

करने के लिए धन्यवाद:

  • PHP 7.4 के तीर कार्यों (-10 अक्षरों) के बारे में याद दिलाने के लिए इस्माइल मिगुएल
  • रात के लिए कुशलतापूर्वक उलट औरjoin() (-8 अक्षर) को
  • Night2 कैसे उपयोग करने के लिए दिखाने के लिए chunk_split()की $endपैरामीटर (-5 अक्षर)

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

PHP 7.3, 117 112 108 वर्ण

function s($s,$r,$c){echo _.chunk_split(($b=str_pad(_,$c,_)).str_shuffle(str_pad($s,$r*$c)),$c,"_
_").$b._;}

करने के लिए धन्यवाद:

  • रात 2 कुशलता और join()(-5 अक्षर) उलटने के लिए
  • Night2 कैसे उपयोग करने के लिए दिखाने के लिए chunk_split()की $endपैरामीटर (-4 अक्षर)

नमूना रन:

php > function s($s,$r,$c){echo _.chunk_split(($b=str_pad(_,$c,_)).str_shuffle(str_pad($s,$r*$c)),$c,"_
php " _").$b._;}
php > s('HELLO', 4, 11);
_____________
_  L        _
_        L  _
_E          _
_    OH     _
_____________

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


1
मेरा मानना ​​है कि fn($s,$r,$c)=>($b=str_repeat(9,$c+2))."\n9".join("9\n9".str_split(str_shuffle(str_pad($s,$r*$c)),$c))."9\n$b";PHP 7.4 ( wiki.php.net/rfc/arrow_functions_v2 ) में काम करना चाहिए , और एक रिलीज़ कैंडिट जारी किया गया है ( wiki.php.net/todo/php74 ), इसलिए, यह एक उपलब्ध "कंपाइलर" है जो आया था इस चुनौती से पहले, और कोई भी इसका उपयोग कर सकता है।
इस्माइल मिगुएल

1
दोहे, आप सही कह रहे हैं। के बारे में पढ़ें, लेकिन भूल गए। (अपने आप को ध्यान दें: अगली बार सिर्फ पढ़ा नहीं Night2 की टिप वोट दें यह भी, शायद याद में मदद करता है।।)
manatwork


1
धन्यवाद, @ रात 2। मैं कल्पना नहीं कर सकता कि मैंने कल क्या गड़बड़ की, क्योंकि मैंने अंदर अधिक सामान ले जाने की कोशिश की join(), लेकिन आकार को कम करने में विफल रहा। ☹
manatwork

1
समझ में आने वाला एक छोटा भी हो गया chunk_split: 94 बाइट्स मैंने पिछले अर्धविराम को भी हटा दिया क्योंकि मेरा मानना ​​है कि इसकी आवश्यकता नहीं है, आपने एक फ़ंक्शन लिखा है, इसलिए कोड जो इसे एक चर पर असाइन करने जा रहा है उसे गिनना नहीं चाहिए।
Night2

3

MATL , 22 19 बाइट्स

tZ"ibpyn&Z@(TT35&Ya

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

धन्यवाद @LuisMendo को 3 बाइट बचाने के लिए, तो अब यह @ दोष के उत्तर के समान ही है , लेकिन फिर भी पोस्ट करने के लिए पर्याप्त रूप से भिन्न है। उच्च-स्तरीय कृषि अवलोकन:

 Z"                  % Create n x m matrix of spaces
           (         % Index into this matrix:
   i                 %  The alphabet vermicelli (explicit input)
        &Z@          %  at a random locations (randperm), which are
      yn             %   length(S) numbers, ranging
t   bp               %   from 1 to n*m
            TT35&Ya  % And finally add a border

आप बदल सकते हैं Z}&Oद्वारा Z", और भी आप अंतिम दूर करने के लिए अनुमति देता हैc
लुइस Mendo

@LuisMendo ओह जो बहुत मदद करता है! यह सोचने के लिए आओ, मुझे कम से कम करना चाहिए था 1$O
Sanchises

3

रूबी , 121 बाइट्स

कटोरा बनाता है, कटोरे के भीतर सभी रिक्त स्थान के सूचकांक पर सवाल उठाता है, स्ट्रिंग के आकार के बराबर कई रिक्त स्थान का नमूना sampleलेता है , और उन्हें भरता है। एक छंटनी सूची वापस नहीं करता है, इसलिए फेरबदल करने की कोई आवश्यकता नहीं है। 9*m*n(जो निश्चित रूप से लगभग सीमा से बाहर चला जाता है) तक सूचकांकों की खोज करना अभी भी सभी रिक्त स्थान प्राप्त करेगा और 1 बाइट से कम है r.size

->s,m,n{r=[t=?@*(n+2),*["@#{' '*n}@"]*m,t]*$/;i=-1;(0..9*m*n).select{|j|r[j]==' '}.sample(s.size).map{|j|r[j]=s[i+=1]};r}

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


3

रेड , 120 116 114 112 बाइट्स

-2 बाइट्स @Kevin क्रूज़सेन को धन्यवाद!

func[s m n][random pad s m * n insert/dup t: copy"00"0 n
print t loop m[print rejoin[0 take/part s n 0]]print t]

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


2
-2 बाइट्स से छुटकारा पाने + 1और to"""00"0 nइसके बजाय का उपयोग करके ।
केविन क्रूज़सेन

1
@ केविनक्रूजसेन धन्यवाद! मैंने इसे copyउसी बाइट की गिनती के साथ बदल दिया ।
गैलेन इवानोव

1
यह वास्तव में थोड़ा साफ दिखता है! मुझे नहीं पता कि मैं आपके द्वारा देखे गए उत्तरों को छोड़कर, इसलिए मैं बस थोड़ा सा चक्कर लगा रहा था। ;) tदो ढीले print tहोने पर बचाने के लिए लूपिंग से पहले लाइन को अग्रणी / अनुगामी मद के रूप में रखना होगा? मुझे इसमें संदेह है, लेकिन चूंकि मुझे नहीं पता कि मैं किसी सूची में आइटम जोड़ना कैसे सुनिश्चित करता हूं।
केविन क्रूज़सेन

3

पर्ल 6 , 74 67 बाइट्स

-5 बाइट्स जो किंग के लिए धन्यवाद

{0 X~0 x$^n,|comb($n,[~] $^s.comb[pick *,^$^m*$n]X//' '),0 x$n X~0}

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

व्याख्या

{                                                                 }
                                         ^$^m*$n  # Range 0 .. M*N-1
                                  pick *,  # Shuffle
                         $^s.comb  # Split S into chars
                                 [              ]  # Pick shuffled elements
                                                 X//' '  # undef to space
                     [~]  # Join
             # Split into n-character strings
             comb($n,                                  )
            |  # Flatten
     # Add top and bottom of bowl
     0 x$^n,                                            ,0 x$n
 # Add left and right of bowl
 0 X~                                                          X~0



3

k4, 32 28 बाइट्स

{4{|+x,'"#"}/y#a?(a:-*/y)$x}

संपादित करें: -4 गैलेन इवानोव के लिए धन्यवाद!

जैसे कहा जाता है

f["hey";3 3]

स्पष्टीकरण:

                 (a:-*/y)    / neg product of y and assign to a 
                         $x  / left pad x so we have char vector the length of the inner area
               a?            / take `a` random drawings. if a is negative, draw with no duplicates/replacements
             y#              / reshape to y's dimensions
 4{        }/                / do {} 4 times 
   |+x,'"#"                  / append "#" along right-side of x then transpose (+) and reverse (|)

1
मुझे लगता है कि आप कुछ बाइट्स बचा सकते हैं यदि आप केवल #प्रत्येक पंक्ति के अंत में संलग्न होते हैं और 4 बार उलट / रिवर्स करते हैं, तो ऐसा कुछ
गैलेन इवानोव

1
@GalenIvanov अच्छा, अद्यतन!
प्रात: काल 7:06

3

जावा (JDK) , 180 178 बाइट्स

एक भी अतिरिक्त आयात नहीं:

(y,m,n)->{for(m*=n;y.length()<m;y+=" ");var s="";for(;m-->0;y=s)for(var c:y.split(s=""))s=Math.random()<.5?s+c:c+s;s="#".repeat(n);return(s+y+s).replaceAll(".{"+n+"}","\n#$0#");}

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

इस गोल्फ को नीचे उतारने के लिए काफी संघर्ष करना पड़ा। विशेष रूप से, Collections.shuffle () / Arrays विधियों में शामिल आयात स्वीकार करने के लिए बहुत अधिक थे, इसलिए मुझे अपना स्वयं का स्ट्रिंग फेरबदल एल्गोरिदम बनाना था (शायद न तो कुशल और न ही समान रूप से वितरित)। एल्गोरिथ्म से किसी भी स्थिति को साबित करने के लिए स्टीवन के लिए बड़े पैमाने पर धन्यवाद ।

प्रारूपित (स्पष्टीकरण के साथ):

(y, m, n) ->                                                   // y = yummies in the soup,
{                                                              // m = height, n = width
    for (m *= n; y.length() < m; y += " ")                     // set m to m*n and
        ;                                                      // add spaces to y to fill up
    var s = "";                                                // the rest of the soup
    for (; m-- > 0; y = s)                                     // for m*n iterations, scramble y
        for (var c : y.split(s = ""))                          // with random appends
            s = Math.random() < .5 ? s + c : c + s;
    s = "#".repeat(n);                                         // create the top/bottom of the rim
    return (s + y + s).replaceAll(".{" + n + "}", "\n#$0#"); // add all sides of the rim
};

अच्छा जवाब! मुझ से +1। गोल्फ के लिए एक छोटी सी बात: .replaceAll("(.{"+n+"})","\n#$1#")बन सकता है.replaceAll(".{"+n+"}","\n#$0#")
केविन Cruijssen

@KevinCruijssen सुधार के लिए धन्यवाद :)
AVI

2

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

NθNη↖B⁺²θ⁺²η#FS«W℅KKJ‽θ‽ηPι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। ऑर्डर चौड़ाई, ऊंचाई, स्ट्रिंग में इनपुट लेता है। स्पष्टीकरण:

NθNη

चौड़ाई और ऊंचाई इनपुट करें।

↖B⁺²θ⁺²η#

कटोरे को फ्रेम करें।

FS«

स्ट्रिंग में पात्रों पर लूप।

W℅KKJ‽θ‽η

एक खाली जगह मिलने तक कटोरे में एक यादृच्छिक स्थिति में कूदें।

Pι

कर्सर को ले जाए बिना वर्तमान वर्ण को प्रिंट करें।


क्या यह Move(:UpLeft)आवश्यक है? यह इसके बिना ठीक काम करता है, लेकिन शायद आपने इसे एक कारण से जोड़ा है जिसके बारे में मुझे नहीं लगता है?
केविन क्रूज़सेन

1
@ केविनक्रूजसेन इसके बिना मैं कभी भी नीचे की पंक्ति या सबसे दाहिने स्तंभ में पत्र नहीं लिख पाऊंगा।
नील

आह, इतना ही था। यह बताते हैं, धन्यवाद!
केविन क्रूज़सेन

2

जाप -R , 21 18 बाइट

úV*W ö¬òW ²Ô²û2W+2

कोशिश करो

úV*W ö¬òW ²Ô²û2W+2     :Implicit input of string U=S and integers V=M & W=N
úV*W                   :Right pad U with spaces to length V*W
     ö¬                :Random permutation
       òW              :Split to array of strings of length W
          ²            :Push 2
           Ô           :Reverse
            ²          :Push 2
             û2W+2     :Centre pad each element with "2" to length W+2
                       :Implicit output, joined with newlines

2

MATL , 29 27 19 बाइट्स

pZ@iy~hw)1GeTT35&Ya

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

धन्यवाद @LuisMendo -8 बाइट्स के लिए!

स्पष्टीकरण: pसूप-पिक्सेल की संख्या की गणना करता है। फिर Z@सूप पिक्सल्स की संख्या के आकार का एक यादृच्छिक क्रमांकन पैदा करता है। हम इसका उपयोग सूचकांकों के रूप में करेंगे, iy~hजिसमें पर्याप्त रिक्त स्थान के साथ इनपुट स्ट्रिंग है। w)दो को स्वैप करता है और एक को दूसरे के साथ अनुक्रमित करता है। हम 1Geआकार को वांछित आयत में फिर से #खोलते हैं और इसका उपयोग करते हुए -pd करते हैं TT35&Ya


2
चतुर! मेरा प्रयास 22 बाइट्स
Sanchises

2
@Sanchises जाओ यह वैसे भी पोस्ट!
दोष

2

टी-एसक्यूएल 2017, 232 बाइट्स

इस ऑनलाइन का परीक्षण एक और चरित्र के वर्ग-सर्वर का एक पुराना संस्करण है। मैंने छोटा संस्करण पोस्ट किया है।

golfed:

DECLARE @ varchar(max)=''SELECT top 999 @+=substring(@i,number+1,1)FROM spt_values
WHERE type='P'and number<@a*@b
ORDER BY newid()WHILE-@b<1SELECT @=stuff(@+' ',@b*@a+1,0,'#
#'),@b-=1PRINT stuff(replicate('#',2+2*@a),2+@a,0,trim(@))

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

Ungolfed:

DECLARE @ varchar(max)=''

SELECT top 999 @+=substring(@i,number+1,1)
FROM spt_values
WHERE type='P'and number<@a*@b
ORDER BY newid()

WHILE-@b<1
SELECT @=stuff(@+' ',@b*@a+1,0,'#
#'),@b-=1
PRINT stuff(replicate('#',2+2*@a),2+@a,0,trim(@))

2

सी (क्लैंग) , 169 164 162 160 बाइट्स

i,b;f(n,m,s)char*s;{char*a,o[b=i=-~++n*(m+=3)];for(srand(time(a=o));--i;)*a++=i%m?-~i%m<3|i<m|i>m*n?35:32:10;for(*a=0;*s;*a=*a-32?*a:*s++)a=o+rand()%b;puts(o);}

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

-2 समय में (=) कॉल // के लिए (srand (समय (a = o)), ...;

सहेजे गए 7 @ceilingcat का उपयोग करने का सुझाव - ~ चर और ऑटो भंडारण के लिए स्ट्रिंग ओ प्लस कई सुधार।

Degolf:

char*a,// pointer for set operations 
*o=malloc(b=i=(m+=3)*(n+=2));  => o[b=i=(m+=3)*-~++n]
// before allocating for the whole bowl as a char array
// increments m by 3 (2 for rims and 1 for '\n') and n by one but allocates for 2(rims)
// and assigns bowl size to i and b.
srand(time(0));// seeds rand function 
for(// loop to make empty bowl 
a=o;// using pointer as iterator
 --i ;)//  i decremented as a counter

 *a=// sets every char to..
 i%m?// if(not) over right side of bowl (m+3)
   -~i%m<3|i<m|i>m*n-m?35// if on rim '#'//-~i == (i+1)
   :32 // else ' ' 
  :10;// i%m==0

for(*a=0;// before loop terminates bowl with \0
 *s;// for every letters(exit on '\n')
 *a=*a-32?*a:*s++)
 // puts letter if bowl at a is a space and
 // go to next letter

 a=o+rand()%b; 
 // sets a to o offsetted by random

puts(o);// prints bowl 

के *a=--i;)*a++=i%m?-~i%m<3|i<m|i>m*n?35:32:10;for(;बजाय सुझाव--i;)*a++=i%m?-~i%m<3|i<m|i>m*n?35:32:10;for(*a=0;
5

@ceilingcat को यह काम करना चाहिए, लेकिन किसी कारण से यह पिछले 2 परीक्षण मामलों पर गलत आउटपुट देता है
AZTECCO


1

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

P⁶ẋaẊs⁸ṪṾ€«”~ZƊ⁺

एक डायडिक लिंक पूर्णांक की एक सूची को स्वीकार करता है, [M, N]बाईं ओर और वर्णों की सूची,S , दाईं ओर जो वर्णों की सूची, पंक्तियों की एक सूची देता है। ~सीमा के रूप में, टिल्ड चरित्र का उपयोग करता है ।

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

सभी संभावित आउटपुटों में एक शून्य-शून्य मौका होता है क्योंकि हम फेरबदल करते हैं ( ) Sरिक्त स्थान की उचित संख्या के साथ पात्रों की एक सूची ।

कोड Ṿ€«”~ZƊ⁺बाइट को सहेजता है जो मुझे लगता है कि नए सिरे से जुड़ने के लिए आवश्यक होगा कि पूर्णांक जैसे शून्य का उपयोग करने वाले पूर्ण कार्यक्रमों को नियोजित करने की आवश्यकता होगी (जैसे P⁶ẋaẊs⁸Ṫ;€0ZUƊ4¡Yया P⁶ẋaẊs⁸Ṫj@€Ø0Z$⁺Y)। शायद अधिक बचत करने का एक तरीका है ...?

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