हिचकी एक स्ट्रिंग

16

आपकी चुनौती एक प्रोग्राम या फ़ंक्शन लिखना है जो एक स्ट्रिंग को हिचकी देता है। इसे इनपुट के रूप में एक स्ट्रिंग लेना चाहिए (किसी भी मानक विधि के माध्यम से), फिर इन चरणों का पालन करें:

  1. एक (जरूरी नहीं समान रूप से) यादृच्छिक पूर्णांक उत्पन्न एन 1 और 10 सहित उनके बीच।
  2. एन सेकंड रुको ।
  3. इनपुट के प्रारंभिक / अगले n वर्ण, या n वर्ण से कम होने पर शेष इनपुट प्रिंट करें ।
  4. यदि प्रिंट करने के लिए इनपुट शेष है, तो चरण 1 पर वापस जाएं।

नियम

  • इनपुट हमेशा एक गैर-रिक्त स्ट्रिंग होगा जिसमें केवल ASCII वर्ण (32-126) होंगे।
  • प्रतीक्षा समय बिल्कुल n सेकंड नहीं होना चाहिए, लेकिन यह n के 10% के भीतर होना चाहिए ।
  • जब भी पाठ का एक भाग छपा हो, आप हर बार एक नई रूपरेखा मुद्रित कर सकते हैं।

उदाहरण

यहाँ एक स्थान 1 सेकंड का प्रतिनिधित्व करता है। यदि इनपुट है Hiccupinator!, तो एक आउटपुट हो सकता है:

   Hic     cupin a          tor!

स्कोरिंग

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

code-golf  string 
— ETHproductions
स्रोत
टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।
— डेनिस
क्या हम उन भाषाओं के लिए रिक्त स्थान का उपयोग कर सकते हैं जो प्रतीक्षा का समर्थन नहीं करती हैं / समय की धारणा नहीं है?
— फ्लिफ़ेई
मैं शर्त लगाता हूं कि किसी भी भाषा के पास आउटपुट का उत्पादन किए बिना समय बिताने का एक तरीका है, @FliiFe!
— उमर

जवाबों:

9

स्क्रैच, 16 ब्लॉक + 6 बाइट्स

कोड

मान लिया गया कि इनपुट पहले से ही वर्णों की सूची के रूप में परिभाषित है ( ["H","e","l","l","o"," ","W","o","r","l","d"])

— OldBunny2800
स्रोत
क्या यह किसी भी तरह से नीचे गिराया जा सकता है?
— ओल्डबुननी 2800
यह एक मान्य स्कोरिंग विधि नहीं है। मेटा पोस्ट देखें ।
— mbomb007 14
क्या आप इसे सामुदायिक सहमति के आधार पर तय करने के लिए तैयार हैं?
— OldBunny2800
1
मेरे पास स्क्रैच नहीं है। जब से आपने उत्तर पोस्ट किया है, यह आपकी जिम्मेदारी है। स्क्रैचब्लॉक 2 भी एक प्रोजेक्ट से टेक्स्ट कोड बनाने के लिए एक जनरेटर के साथ आता है।
— mbomb007
5

पुष्य , 20 17 16 या 13 बाइट्स

अनुमति के आधार पर, दो समाधान हैं।

16 बाइट्स:

@$LT1U&Wm:v;O"cI

कमांड लाइन पर तर्क दें $ pushy hiccup.pshy 'hiccupinator':। यह प्रत्येक 'हिचकी' के बाद नई सुर्खियों में आता है। यहाँ ब्रेकडाउन है:

                      % Implicit: input on stack as charcodes
@                     % Reverse input, so chars are pulled from start
 $             I      % While there are items on stack:
   T1U                %   Push a random number, 1-10
      &W              %   Wait that many seconds
  L     m:            %   min(time waited, chars left) times do:
          v;          %     Pull a char from the input.
            O"c       %   Print & delete pulled chars

13 बाइट्स:

उपर्युक्त उत्तर को कोड करते समय मैं इस छोटे समाधान के साथ आया:

N@$L1TU&Wm:'.

यद्यपि यह एक समान कार्य करता है, यह कम बाइट्स के लिए एक नया स्ट्रिंग बनाने के बजाय सीधे स्ट्रिंग को प्रिंट करता है। इसके लिए आवश्यकता हैNकार्यक्रम की शुरुआत में नई रूपरेखाओं को रोकने के लिए है, अन्यथा प्रत्येक चरित्र एक नई पर होगा।

हालाँकि, इस परीक्षण के दौरान मैंने एक बग देखा - stdout लाइन-बफर है, इसलिए कार्यक्रम पूरी लंबाई की प्रतीक्षा करेगा, और फिर हिचकी स्ट्रिंग प्रदर्शित करेगा।

मैंने इसे नवीनतम प्रतिबद्ध में तय किया है एक साधारण जोड़कर.flush() - यह तकनीकी रूप से भाषा में एक नई सुविधा नहीं जोड़ रहा है, बस एक बग को ठीक कर रहा है, लेकिन मैं समझता हूं कि क्या आप इस उत्तर को ध्यान में नहीं रखते हैं :)

ब्रेकडाउन इस तरह दिखता है:

        % Implicit: input on stack as charcodes
N       % Set trailing newlines to False
@       % Reverse stack (so the charcodes are pulled off in order)
$       % While there are items left to print:
L       %    Push stack length
1TU     %    Push a random number 1-10
&W      %    Wait that amount of time
m:      %    min(time waited, chars left) times do:
'.      %      Pop and print last char
— FlipTack
स्रोत
PPCG में सम्मेलन यह है कि भाषाओं को कार्यान्वयन (कीड़े और सभी) द्वारा परिभाषित किया गया है। चूँकि कमेटी ने चुनौती को स्वीकार कर लिया है, इसलिए यह भाग गैर-प्रतिस्पर्धात्मक है
— लुइस मेंडो
@LuisMendo ठीक है, स्पष्टीकरण के लिए धन्यवाद :)
— FlipTack
अच्छा जवाब BTW :-)
— लुइस मेंडू
4

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

f=s=>s&&setTimeout(_=>console.log(s.slice(0,n))|f(s.slice(n)),(n=1+Math.random()*10)<<10)

console.log(2 + f.toString().length); 
f('Hello sweet world!')
स्निपेट का विस्तार करें

@zeppelin के लिए 2 बाइट्स धन्यवाद बचाया

प्रतीक्षा के लिए प्रतीक्षा समय के लिए 10% सहिष्णुता का दुरुपयोग करता है n<<10 === 1024*nमिलीसेकंड ।

चूंकि आपने कहा था कि प्रतीक्षा समय n के 10% के भीतर होना चाहिए , इसलिए मैंने एक बाइट को बचाने और 1 सेकंड के बजाय 999 मिलीसेकंड की प्रतीक्षा करने का निर्णय लिया।

मुझे @ETHProductions की बदौलत अब 999 मिलीसेकंड की शिथिलता की आवश्यकता नहीं है

— Lmis
स्रोत
1
हम्म, निश्चित नहीं कि अगर किसी भी माप से "यादृच्छिक" के लिए नई तिथि ()% 10 गिना जाए।
— zeppelin
@zeppelin फेयर पॉइंट, मानक परिभाषा के अनुसार इसकी गिनती नहीं है। ( meta.codegolf.stackexchange.com/a/1325/56071 )। मैं उसी के अनुसार इसे बदलूंगा।
— लमिस
आप बाइट्स की एक जोड़ी को भी बचा सकते हैं, "0 |"
— zeppelin
2
आप जानते हैं, आप तीन बाइट्स में 1000 भी व्यक्त कर सकते हैं; 1e3;-)
— 15:25 बजे ETHproductions
1
> (१ + ०.० ९९९९ * १०) * ९९९> १ ९९ but सच है, लेकिन आप शायद + ९९९ को १० से बदल सकते हैं << १०, इस के आसपास काम करने के लिए: (१ + ०.० ९९९९ * १०) << १० => १०२१, (१ + ९.९९९९९ * 10) << 10 => 10240
— टसेपेल्लिन
4

पायथन 2, 93 92 बाइट्स

import random,time
def F(s):
 if s:n=random.randint(1,10);time.sleep(n);print s[:n];F(s[n:])

Flp.Tkc के लिए -1 बाइट धन्यवाद

मुझे यकीन है कि random.randintऔर छोटा करने का एक तरीका है time.sleep, लेकिन from random,time import*काम नहीं करता ...

— acrolith
स्रोत
1
from random,time import*काम नहीं करता है क्योंकि पायथन को पता नहीं है कि आप किस मॉड्यूल से पुस्तकालयों को आयात करना चाहते हैं।
— आउटगोल्फर
पायथन 3 एक बाइट लंबी है। ब्रैकेट से पहले '(' प्रिंट और 'आई' और 'ए') के बीच में डालें
— जॉर्ज
1
मिनीपी (पाइथन 3) के लिए इसे अपनाना: while v1:n=ri(1,10);_i("time").sleep(n);p(v1[:n]);v1=v1[n:];(कमांड लाइन
— आर्ग्स
आप इस 1 बाइट को एक पुनरावर्ती कार्य के रूप में छोटा कर सकते हैं: import random,timeतब def F(s):नई if s:n=random.randint(1,10);time.sleep(n);print s[:n];F(s[n:])
— पंक्ति
3

पर्ल 6 , 62 बाइट्स

{$_=$^a;while $_ {sleep my \t=(1..10).roll;put s/.**{0..t}//}}

विस्तारित

{ # block lambda with parameter ｢$a｣

  $_ = $^a; # declare parameter, and store it in ｢$_｣
            # ( the input is read-only by default )

  while $_ {
    # generate random number and sleep for that many seconds
    sleep my \t=(1..10).roll;

    put
      s/              # substitution on ｢$_｣ ( returns matched text )
        . ** { 0..t } # match at most ｢t｣ characters
      //              # replace it with nothing
  }
}
— ब्रैड गिल्बर्ट b2gills
स्रोत
1

बैच, 131 बाइट्स

@set/ps=
:l
@set/an=%random%%%10+1
@timeout/t>nul %n%
@call echo(%%s:~0,%n%%%
@call set s=%%s:~%n%%%
@if not "%s%"==2" goto l

का उपयोग करते set/pn=<nulहुए एक अच्छा प्रभाव दिया जाएगा सिवाय इसके कि यह रिक्त स्थान को ट्रिम करता है।

— नील
स्रोत
1

पायथ, 16 बाइट्स

Wz.d_JhOT<zJ=>zJ

आप ऐसा कर सकते हैं इसे ऑनलाइन आज़मा , लेकिन यह अच्छी तरह से काम नहीं करता है क्योंकि ऑनलाइन दुभाषिया केवल आउटपुट को दिखाता है एक बार कार्यक्रम समाप्त हो गया है।

व्याख्या

Wz         While z (the input) is not empty:
     hOT   Get a random number between 1-10 (inclusive)
    J      Set the variable J to that number
 .d_       Sleep for that number of seconds
 <zJ       Get and implicitly print the first J characters of the input
  >zJ      Get all characters of z at and after index J
 =         Set z to that string
— insert_name_here
स्रोत
1

MATL , 19 बाइट्स

`10YrtY.ynhX<:&)wDt

यह काम किस प्रकार करता है

इसे ऑनलाइन आज़माएं! ऑनलाइन संकलक धीरे-धीरे पॉज़ के साथ आउटपुट का उत्पादन करता है।

`         % Do...while loop
  10Yr    %   Random integer from 1 to 10
  tY.     %   Duplicate. Pause that many seconds
  y       %   Duplicate the second-top element. This is the remaining string; or it
          %   takes the input implicitly in the first iteration
  n       %   Number of elements
  hX<     %   Minimum of the number of elements and the random number
  :       %   Range from 1 to that
  &)      %   Apply as index. Push the substring as given by the index and the
          %   remaining substring
  w       %   Swap
  D       %   Display
  t       %   Duplicate the remaining substring. This is used as loop condition:
          %   if non-empty execute next iteration
          % End loop implicitly
— लुइस मेंडो
स्रोत
1

बाकोन , 93 बाइट्स

बेसिक में एक समाधान। रैंडम () फ़ंक्शन 0 और n-1 के बीच एक संख्या उत्पन्न करता है, इसलिए हमें 0 और 10 के बीच एक संख्या प्राप्त करने के लिए रैंडम (11) का उपयोग करना होगा।

INPUT s$
WHILE LEN(s$)>0
n=RANDOM(11)
SLEEP n*1000
?LEFT$(s$,n),SPC$(n);
s$=MID$(s$,n+1)
WEND

नमूना सत्र, पहली पंक्ति इनपुट है, दूसरा आउटपुट:

Hiccupinator!
Hiccupi       nato    r!
— पीटर
स्रोत
2
यदि आप जो कहते हैं वह सत्य है तो आपका यादृच्छिक कार्य होना चाहिए n=RANDOM(10)+1, आपकी लाइन ऑफ कोड 0-10 समावेशी से एक संख्या उत्पन्न करेगा, 1-10 नहीं
— ऑक्टोपस
1
@ ओक्टोपस इससे कोई फर्क नहीं पड़ता, क्योंकि यह बिना किसी समय के सोएगा और उस मामले में कोई आउटपुट नहीं देगा।
— नील
मेरे स्पष्टीकरण में टाइपो को ठीक किया।
— पीटर
1

पर्ल, 42 बाइट्स

41 बाइट्स कोड + 1 के लिए -n।

$|=$-=--$-||sleep 1+rand 10,print for/./g

मुझे पर्ल को आउटपुट को फ्लश करने के लिए मजबूर करना पड़ा क्योंकि यह पहले कुछ भी नहीं दिखा रहा था, इसलिए सेटिंग $|। हम $-वर्णों की संख्या को ट्रैक करने के लिए उपयोग करते हैं printक्योंकि यह नकारात्मक नहीं हो सकता है (इसलिए मैं उपयोग कर सकता हूं --$-और जब यह खाली होगा तो झूठा हो जाएगा) और यह भीfloor , हालांकि जब से मैं sleepइस के लिए वापसी का उपयोग कर रहा हूं , तब से यह नहीं है 'वास्तव में बात नहीं है।

प्रयोग

perl -ne '$|=$-=--$-||sleep 1+rand 10,print for/./g' <<< 'Hello, World!'
    Hell      o, Wor     ld!
# spaces showing delay!
— डोम हेस्टिंग्स
स्रोत
0

> <> (मछली) 103 88 बाइट्स

5>:?vl1-?!v+40.    >~
   1x2v   
>^  0  |:!/>:?!v1-b2.
^-1}< <     |~!/:?!^1-i:1+?!;of3.

ऑनलाइन दुभाषिया यहाँ पाया!

इस समस्या पर पहला प्रयास (गोल्फ नहीं)।

यह एक निश्चित मात्रा में लूप का इंतजार करता है (n) क्योंकि मछली में टाइमर नहीं है जो सुलभ है (टिक्सेस में निष्पादन)।

संपादन 1: अंतिम पंक्ति को शीर्ष पर ले जाया गया (अंतिम 2 वर्ण और आरंभिक मानों का पुन: उपयोग किया। 15 बाइट्स की बचत)

— पिला पेलिकन
स्रोत
0

बैश, 78 बाइट्स

जैसा कि किसी ने अभी तक एक बैश समाधान पोस्ट नहीं किया है, यहां एक है। सीधा, फिर भी काफी छोटा।

golfed

H() { N=$(($RANDOM%10+1));sleep $N;echo ${1:0:$N};S=${1:$N};[ "$S" ] && H $S;}

परीक्षा

>H "It's the Hiccupinator"
It's the
Hiccupi
n
ator
— टसेपेल्लिन
स्रोत
0

पीएचपी, 81 बाइट्स

for(;''<$s=&$argv[1];$s=$f($s,$n))echo($f=substr)($s,0,sleep($n=rand(1,10))?:$n);

जैसे उपयोग करें:

php -r "for(;''<$s=&$argv[1];$s=$f($s,$n))echo($f=substr)($s,0,sleep($n=rand(1,10))?:$n);" "Hiccupinator!"
— user59178
स्रोत
0

सी ++ 14, 202 बाइट्स

#import<thread>
void f(auto c){if(c.size()<1)return;int n=(uintptr_t(&c)%99)/10+1;std::this_thread::sleep_for(std::chrono::seconds(n));std::cout<<c.substr(0,n)<<std::endl;f(n<c.size()?c.substr(n):"");}

एक होने के लिए इनपुट की आवश्यकता है std::string

अधूरा और उपयोग:

#include<iostream>
#include<string>

#import <thread>

void f(auto c){
  if (c.size() < 1) return;
  int n=(uintptr_t(&c) % 99) / 10 + 1;
  std::this_thread::sleep_for(std::chrono::seconds(n));
  std::cout << c.substr(0,n) << std::endl;
  f(n < c.size() ? c.substr(n) : "");
}

int main(){
  std::string s="abcdefghijklmnopqrstuvwxyz";
  f(s);
}
— कार्ल नेफ
स्रोत
using namespace std;उन सब की तरफ से 5 बाइट्स सहेजना चाहिए std::रों
— Alfie Goodacre
@AlfieGoodacre 5 वीं std::केवल उपयोग कोड में है, गोल्फ वाले में केवल 4 हैं
— कार्ल
आह तो यह समान है!
— अल्फी गुडाक्रे
0

सी #, 205 बाइट्स

void X(string s){Random r=new Random();int n=r.Next(1,11);while(n<s.Length){Console.WriteLine(s.Substring(0,n));s.Remove(0,n);n*=1000;System.Threading.Thread.Sleep(n);n=r.Next(1,11);}Console.WriteLine(s);}

मुझे यकीन है कि इसे नष्ट किया जा सकता है, मैंने वास्तव में इसे अनुकूलित नहीं किया है क्योंकि यह खड़ा है।

संयुक्त राष्ट्र के golfed:

void X(string s)
{
    Random r = new Random();
    int n = r.Next(1,11);
    while(n < s.Length)
    {
        Console.WriteLine(s.Substring(0,n));
        s.Remove(0,n);
        n *= 1000;
        System.Threading.Thread.Sleep(n);
        n = r.Next(1,11);
    }
    Console.WriteLine(s);
}
— अल्फी गुडाकरे
स्रोत
0

PHP, 74 बाइट्स

for($s=$argv[1];$s[$p+=$n]>"";print substr($s,$p,$n))sleep($n=rand(1,10));

साथ चलाना php -r 'code' "string"।

— टाइटस
स्रोत
0

सी, 149 बाइट्स, परीक्षण नहीं किया गया

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int f(char *s){int n;while(*s){sleep(n=rand()%10+1);for(;*s&&n--;s++)printf("%.*s",1,s);}}

चलाना, जोड़ना

int main(){f("Programming Puzzles & CodeGolf");}

फिर संकलित करें और निष्पादित करें

— टाइटस
स्रोत
0

पायथन 3, 99 वर्ण

i=input()
import os,time
while len(i):n=1+ord(os.urandom(1))%10;time.sleep(n);print(i[:n]);i=i[n:]
— vpzomtrrfrt
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.