हेलोयोलोलू वर्ल्डवर्ल्डल्डल्ड

50

एक प्रोग्राम बनाएं जो शब्द आपको इनपुट करता है, और उस शब्द को अपने पहले अक्षर के पीछे से जोड़ता है, तब तक दोहराता है जब तक कि सभी पत्र नहीं चले जाते। उदाहरण के लिए, catबन जाएगा catatt, और helloबन जाएगा helloellolloloo।


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

आउटपुट
शब्द (ओं) को इनपुट किया गया है, प्रत्येक शब्द के साथ अपने पहले अक्षर के लापता होने के बाद, और फिर इसके दूसरे पत्र के लापता होने के साथ, और तब तक जब तक कि कोई और अक्षर जोड़ने के लिए नहीं हैं।

और ज्यादा उदाहरण:

ill eel आउटपुट illlll eelell

laser bat आउटपुट laserasersererr batatt

darth vader आउटपुट dartharthrththh vaderaderdererr

यह कोड गोल्फ है, इसलिए सबसे छोटा कोड जीतता है।

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

code-golf  string 
— qazwsx
स्रोत
22
ईमानदारी से, कई शब्दों की बात थोड़े कष्टप्रद है। सभी को यह एक विभाजन की आवश्यकता होती है, प्रत्येक शब्द पर फ़ंक्शन लागू करें, और फिर फिर से जुड़ें। यह भी बहुत सारे esolangs के लिए दुर्बल है, जिन्हें मैन्युअल रूप से एक स्थान की जाँच करनी है
— Jo King
4
क्या हम इनपुट को शब्दों और आउटपुट की सूची के रूप में ले सकते हैं?
— क्विंट सेक
4
आपको किस लंबाई के शब्द को संभालने की आवश्यकता है?
— मिकट
5
क्या शब्दों के लिए आउटपुट (एक स्थान के बजाय) में एक नईलाइन द्वारा अलग किया जाना ठीक है?
— JayCe
10
1.कृपया नए भत्ते (सरणी I / O, अनुगामी स्थान, आदि) के साथ युक्ति को अपडेट करें। 2.कृपया मौजूदा समाधानों को सूचित करें यदि कोई भी लाभ उठाकर बाइट्स बचा सकता है।
— झबरा

जवाबों:

34

जाप -m, 6 3 बाइट्स

इनपुट और आउटपुट शब्दों के सरणियाँ हैं।

£sY

कोशिश करो

व्याख्या

        :For each word in the input array
£       :Map each letter at index Y
 sY     :  Slice the current word from index Y
— झबरा
स्रोत
1
यह वास्तव में कॉम्पैक्ट है। अच्छा!
— क्वाजवेक्स
9
@qazwsx: अब 50% अधिक कॉम्पैक्ट!
— झबरा
1
£UTF-8 में दो बाइट्स नहीं है ?
— वि।
7
@Vi, मैं यहाँ UTF-8 का उपयोग नहीं कर रहा हूँ।
— शैगी
36

ब्रेनफक , 60 56 बाइट्स

,[>++++++++[-<----<++++>>]<[>>]<[[<]>.[[-]>[.>]<[<]>]],]

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

एक अनुगामी स्थान की आवश्यकता होती है और एक अग्रणी स्थान प्रिंट करता है। इन दोनों को दरकिनार किया जा सकता है, लेकिन यह 112 बाइट्स पर समाप्त होता है ।

व्याख्या

,[  Loop over each byte of input
  Tape: 32 w o r-32 d'
  >++++++++[-<----<++++>>]   Subtract 32 from the character and add 32 to the previous char
  Tape: 32 w o r d-32 0'
  <[>>]<   If the last character was a space
  Tape: 32 w o r d-32 0'
  or
  Tape: 32 w o r d' space-32
  [
    [<]>.   Move to the end of the word and print out the space
    [   Loop over each letter
      [-]    Remove the first letter (initially space)
      >[.>]  Print the rest of the word
      <[<]>  Move back to the first letter
    ]
    Tape: clear
  ]
,]  Get the next byte of input
— मजाक कर रहा है
स्रोत
21

हास्केल, 36 21 बाइट्स

map$concat.scanr(:)""

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

संपादित करें: -15 बाइट्स, नए IO प्रारूप के कारण (शब्दों की सूची के बजाय अंतरिक्ष से अलग शब्द)

— nimi
स्रोत
आप की जगह 5 अक्षर बंद दाढ़ी सकता है scanr (:) ""के साथ tails।
— Frerich Raabe
1
@FrerichRaabe: हाँ, लेकिन इसके import Data.Listलिए स्कोर में 17 बाइट्स की आवश्यकता होगी ।
— नीम
18

पर्ल -p, 36 25 23 बाइट्स

s!\b|\S!$'=~s/ .*//r!eg

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

यह एक एकल regsub है। सबसे पहले, यह सभी शब्द सीमाओं या गैर-अंतरिक्ष वर्णों से मेल खाता है:

[][H][e][l][l][o] [][W][o][r][l][d]

ध्यान दें कि इनमें से प्रत्येक मैच को बाकी शब्दों से बदल दिया जाना चाहिए:

[→Hello][H→ello][e→llo][l→lo][l→o][o→] (...)

हम इसे विशेष चर के साथ पूरा कर सकते हैं $', जो मैच के बाद स्ट्रिंग के हिस्से को संग्रहीत करता है। हालांकि, हमें इसके लिए नेस्टेड रिबस को लागू करने की आवश्यकता है s/ .*//, जो $'इनपुट में शेष शब्दों से छुटकारा पाने के लिए, पहले स्थान के अतीत को हटा देता है ।

2 बाइट्स के लिए @nwellnhof को धन्यवाद ।

— Doorknob
स्रोत
आप बदल सकते हैं [^ ]के साथ \S।
— nwellnhof
17

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

d=lambda s:' '.join(n+d(n[1:])for n in s.split())

यह ऑनलाइन की कोशिश करो!

यह इस तथ्य का लाभ उठाता है कि "".split()खाली सरणी देता है ताकि पुनरावृत्ति में आधार मामले की जांच के रूप में कार्य किया जा सके।

— कैमरन अविक
स्रोत
17

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

ḊƬ€

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

Kसरणी इनपुट / आउटपुट अब अनुमति दी गई है क्योंकि अब एस की जरूरत नहीं है ।

ḊƬ€
  €   For each word:
Ḋ       Remove the first letter
 Ƭ      until there are none left.
— dylnan
स्रोत
मुझे लगता है कि आपको आवश्यकता है ḊƬẎ)(या ḊƬF), यदि आप पसंद करते हैं)।
— आउटगॉल्फ
@EriktheOutgolfer मुझे ऐसा नहीं लगता। प्रत्येक शब्द को आउटपुट में एक अलग सरणी द्वारा दर्शाया गया है
— dylnan
1
मुझे यकीन नहीं है कि आप यह दावा कर सकते हैं कि, चूंकि सरणियाँ नेस्टेड हैं, और इसे अनुमति देने के लिए प्रश्न में कुछ भी निर्दिष्ट नहीं है।
— आउटगॉल्फ
15

एपीएल (डायलॉग), 19 9 बाइट्स

{⌽∊,\⌽⍵}¨

मेरे दिमाग को जॉगिंग करने के लिए @ H.PWiz को धन्यवाद

यह काम करता है क्योंकि एपीएल में सभी तार चरित्र सरणियों हैं।

{⌽∊,\⌽⍵}¨ 
        ¨ - for each string
      ⍵} - string argument - ex. "hello"
     ⌽ - reverse - "olleh"
   ,\ - scan magic - "o" "ol" "oll" "olle" "olleh"
  ∊ - enlist(join together) "oolollolleolleh"
{⌽ - reverse - "helloellolloloo"

TIO

— Quintec
स्रोत
15

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

@ बायरसेकसोटो को 1 बाइट धन्यवाद दिया

I / O प्रारूप: शब्दों की सरणी।

a=>a.map(g=w=>w&&w+g(w.slice(1)))

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

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

I / O प्रारूप: शब्दों की सरणी।

a=>a.map(w=>w.replace(/./g,"$&$'"))

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

— Arnauld
स्रोत
2
44:s=>s.replace(/\S+/g,g=s=>s&&s+g(s.slice(1)))
— शायरु असाकोतो
1
आज के लिए मेरे "कुछ नया" के लिए धन्यवाद; $'(या $<backtick>) के बारे में कभी नहीं पता था ।
— झबरा
13

आर , 82 75 67 बाइट्स

write(sapply(x<-scan(,""),substring,1:(y=max(nchar(x))),y),1,y,,"")

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

कई बाइट्स ने जेसीई को धन्यवाद दिया

आउटपुट को नईलाइन के साथ अलग करता है।

sapply(...)अभिव्यक्ति के साथ उचित सबस्ट्रिंग के एक मैट्रिक्स / स्तंभ वेक्टर, गद्दी उत्पन्न करता है ""के रूप में की जरूरत है। writeफिर मैट्रिक्स के तत्वों को yप्रति पंक्ति प्रिंट करता है , उन्हें अलग करता है ""।

— ग्यूसेप
स्रोत
4
नींद वाले बच्चे को पकड़ते हुए एक अलग दृष्टिकोण कायम करना; बाद में एक स्पष्टीकरण जोड़ देगा।
— Giuseppe
2
यदि शब्दों की लंबाई प्रतिबंधित है, उदाहरण के लिए 99 वर्ण या ~ 1e6 तो आप बाइट्स का एक गुच्छा ...substring,1:1e6,1e6)...या इसके साथ दस्तक दे सकते हैं
— मिकी
2
यदि आप शब्दों को एक नई रेखा से अलग कर सकते हैं: tio । मैंने एक टिप्पणी में यह पूछा है। @ मिकी की टिप्पणी के साथ काम कर सकते हैं
— JayCe
@JayCe ऐसा लगता है कि मिकी के सुझाव को शामिल करने से पहले 67 बाइट्स हो सकते हैं
— Giuseppe
8

ब्रेनफक , 94 93 बाइट्स

-[-[-<]>>+<]>-<<+[[[-]<,[->+>+<<]>[-<+>]>>[-<->>+<]<]<<[>>+<<[-]]<[<]>[[.>]<[<]>[-]>]>>>>.<<]

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

व्याख्या

[[[ (dynamic) tape layout: ... NUL STR ... STR CHR FLG BUF SPC NUL ... ]]]

load a 32 into SPC
-[-[-<]>>+<]>-

while FLG
<<+[

 read a word
 [
  clear FLG; read CHR
  [-]<,
  copy CHR to BUF (using FLG as a temporary)
  [->+>+<<]>[-<+>]
  subtract SPC from BUF and save SPC
  >>[-<->>+<]
  move tape layout one to the right
  <
 ]

 strip trailing space; set FLG to true
 << [>>+<<[-]]
 to STR's first character
 <[<]>
 print word in all reduced forms
 [
  [.>]<[<]>[-]>
 ]

 print SPC; move to FLG
 >>>>.<<
]

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

आरोपण

प्रारंभिक अंतरिक्ष भार के लिए एसोलैंग के ब्रेनफक निरंतर संग्रह का उपयोग किया गया था।

— जोनाथन फ्रेच
स्रोत
यह समाप्त करने के लिए प्रतीत नहीं होता है। क्या यह इरादा है?
— जो राजा
1
@ जोकिंग हाँ। कुछ कार्यान्वयन में यह त्रुटि से बाहर निकलते हुए, टेप सीमा से अधिक होगा।
— जोनाथन फ्रेच
6

05AB1E , 5 बाइट्स

€.síJ

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

व्याख्या

€.s        # push suffixes of each
   í       # reverse each
    J      # join suffixes
— Emigna
स्रोत
1
बोरिंग 5-बाइट्स विकल्प: í€ηJí(क्योंकि उपसर्ग प्रत्यय के 2-बाइट प्रत्यय के बजाय एक 1-बाइट बिलिन है; फिर भी शुरुआत में हालांकि एक अतिरिक्त रिवर्स-प्रत्येक की आवश्यकता होती है, इसलिए बाइट-गिनती 5 बनी हुई है)।
— केविन क्रूज़सेन
6

विम , 47 बाइट्स (38 कुंजी स्ट्रोक)

Vim बफर में एकमात्र लाइन के रूप में अपने इनपुट के साथ शुरू करें।

:s/<Space>/\r/g<CR>ggqaywPlxqqb99@aj0q99@bgg99J

व्याख्या

यह प्रत्येक शब्द को अपनी पंक्ति में रखता है, प्रत्येक पंक्ति पर पुनरावृत्त करता है, फिर उन सभी को फिर से जोड़ता है। यदि शब्द 99 वर्णों से अधिक लंबे हों या यदि आपके इनपुट में 99 से अधिक शब्द हों तो तोड़ता है।

  1. :s/<Space>/\r/g<CR> नई लाइनों के साथ रिक्त स्थान की जगह ( \r)
  2. gg पहली पंक्ति की शुरुआत में कर्सर रखता है
  3. qaमैक्रो रिकॉर्ड करना शुरू करता है a :
  4. qbमैक्रो बी रिकॉर्ड करना शुरू करता है :
    • 99@aएक निन्यानबे बार मैक्रो निष्पादित करता है (चरित्र सीमा का परिचय देता है)
    • j0 अगली पंक्ति की शुरुआत में कर्सर को रखता है
    • qरिकॉर्डिंग मैक्रो b
  5. 99@bमैक्रो बी निन्यानबे बार निष्पादित करता है (शब्द सीमा का परिचय)
  6. gg कर्सर को पहली पंक्ति में रखता है
  7. 99J रिक्त स्थान के साथ निन्यानबे पंक्तियाँ जुड़ती हैं (शब्द सीमा फिर से)

अन्य 2 बाइट्स (2 कुंजी स्ट्रोक) के लिए आप शब्द सीमा को 999 तक बढ़ा सकते हैं। अन्य 4 बाइट्स, 9999, आदि।

— chambln
स्रोत
6

भूसी , 6 4 बाइट्स

जोनाथन एलन के लिए -2 बाइट्स धन्यवाद (एक सूची के रूप में इनपुट लेना)!

moΣṫ

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

व्याख्या

इनपुट को स्ट्रिंग की सूची के रूप में लेता है और निम्नलिखित फ़ंक्शन को मैप करता है:

Σṫ  -- example argument: "abc"
 ṫ  -- tails: ["abc","bc","c"]
Σ   -- concat: "abcbcc"
— ბიმო
स्रोत
विभाजन और जुड़ाव की अब आवश्यकता नहीं है, वर्तमान में इस तरह के विनिर्देश एक टिप्पणी में हैं।
— जोनाथन एलन
5

रेटिना 0.8.2 , 15 बाइट्स

 
¶
.
$&$%'
¶

इसे ऑनलाइन आज़माएं! नोट: अनुगामी रिक्त स्थान। स्पष्टीकरण:

रिक्त स्थान पर विभाजित करें।

.
$&$%'

प्रत्येक अक्षर पर इसके प्रत्यय को लगाएं। इसका %मतलब है कि हम केवल शब्द का प्रत्यय प्राप्त करते हैं।

रिक्त स्थान के साथ जुड़ें।

— नील
स्रोत
5

16-बिट x86 असेंबली कोड, 24 बाइट्स

     47             inc    di
     B020           mov    al,20h
l1:  3806           cmp    [si],al
     7212           jb     l5 ;less means end of string
     7401           je     l2  ;equal means space was seen
     4F             dec    di ;overwrite extra space
l2:  E80300         call   l3
     46             inc    si ;move to next character in word
     75F1           jne    l1
l3:  56             push   si
l4:  3806           cmp    [si],al
     A4             movsb      ;copy character
     77FB           ja     l4  ;until either zero or space is seen
     5E             pop    si
l5:  C3             ret

सी = पॉइंटर से सोर्स स्ट्रिंग, डि = पॉइंटर से आउटपुट बफर तक कॉल करें।
स्रोत स्ट्रिंग को इसे समाप्त करने के लिए एक शून्य बाइट की आवश्यकता होती है।
कोड 16- या 32- या 64-बिट (si / di या तो esi / edi या rsi / Jdi) में समान है।
32-बिट कोड विस्तारित कॉल के कारण दो बाइट्स बड़ा है।
64-बिट कोड तीन बाइट्स अभी भी बड़ा है क्योंकि rsi / rdi का inc / dec एक उपसर्ग को आकर्षित करता है (लेकिन अगर यह पता है कि वे 32-बिट मेमोरी स्पेस में हैं, तो वे उस पेनल्टी से बचने के लिए फिर से esi / edi हो सकते हैं) ।

— पीटर फेरि
स्रोत
4

MATL , 18 16 बाइट्स

"@gXH"HX@Jh)]0&h

इनपुट शब्दों का एक सेल ऐरे है। इसे ऑनलाइन आज़माएं!

व्याख्या

"         % Implicit input: cell array of strings. For each cell
  @g      %   Push content of current cell, that is, a word
  XH      %   Copy into clipboard H
  "       %   For each letter
    H     %     Push word
    X@    %     Push iteration index
    Jh)   %     Index from that until the end into current word
  ]       %   End
  0       %   Push 0. Will be cast to char. Char(0) is displayed as space
  &h      %   Concatenate horizontally all elements so far. Implicit display
— लुइस मेंडो
स्रोत
4

सी ++ (क्लैंग) , 174 बाइट्स

#include<map>
#include<string.h>
std::string r(std::string w){while(auto x=strchr(w.c_str(),32))return r(w.substr(0,x-w.c_str()))+" "+r(x+1);return w!=""?w+r(w.substr(1)):w;}

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

यह मेरा पहला सबमिशन है, और मुझे नहीं पता था कि क्या छपाई के बजाय स्ट्रिंग वापस करना ठीक है :)

— QJot
स्रोत
2
PPCG में आपका स्वागत है! हां, एक स्ट्रिंग वापस करना ठीक है। आशा है कि आप चारों ओर छड़ी!
— जो किंग
आप एक स्थान को हटाने के लिए असमानता ऑपरेटर की समरूपता का उपयोग कर सकते हैं और इस तरह एक बाइट बचा return w!=""?सकते हैं - हो सकता है return""!=w?।
— जोनाथन फ्रेच
3

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

⪫Ｅ⪪Ｓ ⭆ι✂ιμＬι¹

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

   Ｓ            Input string
  ⪪             Split on spaces
 Ｅ              Map over each word
      ι         Current word
     ⭆          Map over each character and join
        ι       Current word
         μ      Current index
           ι    Current word
          Ｌ     Length
            ¹   Literal 1
       ✂        Slice
⪫               Join with spaces
                Implicitly print
— नील
स्रोत
3

पिप -s , 11 बाइट्स

J_@>,#_Mq^s

स्टड से शब्दों की अंतरिक्ष से अलग सूची लेता है। इसे ऑनलाइन आज़माएं!

व्याख्या

             s is space (implicit)
        q    Read a line of stdin
         ^s  Split it on spaces
       M     Map this lambda function to each word:
 _            The word...
  @>          sliced starting at index...
    ,#_       range(len(word))
              This creates len(word) slices ["word" "ord" "rd" "d"]
J             Join those into a single string
             The resulting list of modified words is printed; the -s flag uses space
             as the separator
— DLosc
स्रोत
3

सी #, 111 90 बाइट्स

b=>string.Join(" ",(b.Split(' ').Select(x=>string.Concat(x.Select((y, i)=>x.Substring(i))))))

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

सरणियों में इनपुट और आउटपुट में परिवर्तन करके, मैंने कुछ बाइट्स बचाए:

b=>b.Select(x=>string.Concat(x.Select((y,i)=>x.Substring(i)))).ToArray()

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

— LiefdeWen
स्रोत
3

के (ओके) , 17 13 बाइट्स

{,/|:'|,\|x}'

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

उपसर्ग गुमनाम समारोह; इनपुट को स्ट्रिंग्स की एक सूची के रूप में लिया जाता है, जो बदले में पात्रों की सूची है।

4 बाइट्स के लिए @streetster धन्यवाद।

किस तरह:

{,/|:'|,\|x}' //Main function, argument x → ("ill";"eel")
            ' // For each element of the argument
         |x}  // Flip it. x → ("lli";"lee")
       ,\     // Concatenate each element, keeping intermediates. x → (("l";"ll";"lli");("l";"le";"lee")
      |       // Flip it again. x → (("lli";"ll";"l");("lee";"le";"l"))
   |:'        // Now flip each element. x → (("ill";"ll";"l");("eel";"el";"l"))
{,/           // Concatenation scan. x → ("illlll";"eelell")
— जे। सल्ल
स्रोत
आप एक सूची लौट सकते हैं, यह भी मेरे पर एक नज़र डालें ठीक समाधान
— streetster
@streetster ओह, अच्छा है। मैं अभी भी कश्मीर सीखने की प्रक्रिया में हूं, इसलिए मेरे समाधान उतने कम या सुरुचिपूर्ण नहीं होंगे जितना मैं चाहूंगा। सर उठाने के लिए धन्यवाद!
— जे। सेले
रिवर्स से पहले {|,/,\|x}'
— चपटे
3

आम लिस्प , 179 बाइट्स

(defun r(s)(cond((endp s)nil)((eql(first s)#\Space)(princ " ")(r(rest s)))(t(q s)(r(rest s)))))(defun q (l)(cond((eql(first l)#\Space)t)((endp l)t)(t(princ(first l))(q(rest l)))))

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

किसी भी संपादन का स्वागत करने के लिए यह मेरा पहला प्रयास है

— JRowan
स्रोत
नमस्कार और पीपीसीजी में आपका स्वागत है। व्हॉट्सएप को हटाने से आप 29 बाइट बचा सकते हैं ।
— जोनाथन फ्रीच
@ जोनाथन फ्रीच धन्यवाद मैं अभी बिना किसी रिक्त स्थान के साथ अद्यतन किया गया
— JRowan
मुझे लगता है कि आपने चार शानदार स्थान खो दिए हैं।
— जोनाथन फ्रीच
आप संभवतः carइसके स्थान पर उपयोग कर सकते हैं firstऔर cdrइसके बजाय restअपने सबमिशन को आगे बढ़ाना चाहते हैं।
— जोनाथन फ्रेच
ना, इसके साथ अच्छा है अब हा, शायद बीमार वापस आओ और बाद में इसके साथ गड़बड़ करें। Im बस सीखने में अब मेरे शिक्षक ने कहा कि कार और सीडीआर का उपयोग कभी न करें, इसलिए वे मेरे सिर से बाहर थे जब मैं यह कर रहा था
— JRowan
3

लुआ , 70 बाइट्स

for i=1,#arg do x=arg[i]for i=1,#x do io.write(x:sub(i))end print()end

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

व्याख्या

Lua में दलीलें argसूचकांक 1 से शुरू होने वाली तालिका में संग्रहीत की जाती हैं । यूनिरी ऑपरेटर #तालिका का आकार लौटाता है और फ़ंक्शन पूर्णांक के s:sub(a,b)आधार पर स्ट्रिंग के आधार पर एक विकल्प देता है और , यदि b पास नहीं होता है तो यह शेष स्ट्रिंग को लौटा देगा।sab

मुझे लाइन ब्रेकिंग से बचने के io.write()बजाय उपयोग करना पड़ा print(), और print()विपरीत कारण के लिए अंत में जोड़ा गया ।

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