कोड गोल्फ: Collatz अनुमान

Question 1

से प्रेरित होकर http://xkcd.com/710/ यहाँ इसके लिए एक कोड गोल्फ है।

चुनौती

0 से अधिक एक सकारात्मक पूर्णांक को देखते हुए, उस संख्या के लिए हेलस्टोन अनुक्रम का प्रिंट आउट लें।

हैलस्टोन अनुक्रम

अधिक विस्तार के लिए विकिपीडिया देखें ..

यदि संख्या समान है, तो इसे दो से विभाजित करें।
यदि संख्या विषम है, तो इसे तीन गुना करें और एक जोड़ें।

1. पहुंचने तक उत्पन्न संख्या के साथ इसे दोहराएं (यदि यह 1 के बाद भी जारी रहता है, तो यह अनंत लूप में जाएगा 1 -> 4 -> 2 -> 1...)

कभी-कभी कोड समझाने का सबसे अच्छा तरीका है, इसलिए यहां विकिपीडिया से कुछ है

function collatz(n)
  show n
  if n > 1
    if n is odd
      call collatz(3n + 1)
    else
      call collatz(n / 2)

यह कोड काम करता है, लेकिन मैं एक अतिरिक्त चुनौती पर जोड़ रहा हूं। ओवरफ्लो को ढेर करने के लिए कार्यक्रम कमजोर नहीं होना चाहिए । तो यह या तो पुनरावृत्ति या पूंछ पुनरावृत्ति का उपयोग करना चाहिए।

इसके अलावा, बोनस अंक अगर यह बड़ी संख्या की गणना कर सकता है और भाषा पहले से ही इसे लागू नहीं करती है। (या यदि आप निश्चित लंबाई पूर्णांक का उपयोग करके बड़ी संख्या के समर्थन को लागू करते हैं)

परीक्षण का मामला

Number: 21
Results: 21 -> 64 -> 32 -> 16 -> 8 -> 4 -> 2 -> 1

Number: 3
Results: 3 -> 10 -> 5 -> 16 -> 8 -> 4 -> 2 -> 1

इसके अलावा, कोड गोल्फ में पूर्ण उपयोगकर्ता इनपुट और आउटपुट शामिल होना चाहिए।

Question 2

x86 असेंबली, 1337 वर्ण

;
; To assemble and link this program, just run:
;
; >> $ nasm -f elf collatz.asm && gcc -o collatz collatz.o
;
; You can then enjoy its output by passing a number to it on the command line:
;
; >> $ ./collatz 123
; >> 123 --> 370 --> 185 --> 556 --> 278 --> 139 --> 418 --> 209 --> 628 --> 314
; >> --> 157 --> 472 --> 236 --> 118 --> 59 --> 178 --> 89 --> 268 --> 134 --> 67
; >> --> 202 --> 101 --> 304 --> 152 --> 76 --> 38 --> 19 --> 58 --> 29 --> 88
; >> --> 44 --> 22 --> 11 --> 34 --> 17 --> 52 --> 26 --> 13 --> 40 --> 20 --> 10
; >> --> 5 --> 16 --> 8 --> 4 --> 2 --> 1
; 
; There's even some error checking involved:
; >> $ ./collatz
; >> Usage: ./collatz NUMBER
;
section .text
global main
extern printf
extern atoi

main:

  cmp dword [esp+0x04], 2
  jne .usage

  mov ebx, [esp+0x08]
  push dword [ebx+0x04]
  call atoi
  add esp, 4

  cmp eax, 0
  je .usage

  mov ebx, eax
  push eax
  push msg

.loop:
  mov [esp+0x04], ebx
  call printf

  test ebx, 0x01
  jz .even

.odd:
  lea ebx, [1+ebx*2+ebx]
  jmp .loop

.even:

  shr ebx, 1
  cmp ebx, 1
  jne .loop

  push ebx
  push end
  call printf

  add esp, 16
  xor eax, eax
  ret

.usage:
  mov ebx, [esp+0x08]
  push dword [ebx+0x00]
  push usage
  call printf
  add esp, 8
  mov eax, 1
  ret

msg db "%d --> ", 0
end db "%d", 10, 0
usage db "Usage: %s NUMBER", 10, 0

Question 3

Befunge

&>:.:1-|
  >3*^ @
  |%2: <
 v>2/>+

Question 4

LOLCODE: 406 CHARAKTERZ

HAI
BTW COLLATZ SOUNDZ JUS LULZ

CAN HAS STDIO?

I HAS A NUMBAR
BTW, I WANTS UR NUMBAR
GIMMEH NUMBAR

VISIBLE NUMBAR

IM IN YR SEQUENZ
  MOD OF NUMBAR AN 2
  BOTH SAEM IT AN 0, O RLY?
    YA RLY, NUMBAR R QUOSHUNT OF NUMBAR AN 2
    NO WAI, NUMBAR R SUM OF PRODUKT OF NUMBAR AN 3 AN 1
  OIC
  VISIBLE NUMBAR
  DIFFRINT 2 AN SMALLR OF 2 AN NUMBAR, O RLY?
    YA RLY, GTFO
  OIC
IM OUTTA YR SEQUENZ

KTHXBYE

TESTD UNDR जस्टिन जे MEZA'S INTERPRETR । निजता सार्वजनिक

Question 5

पायथन - 95 64 51 46 चार

जाहिर है स्टैक ओवरफ्लो का उत्पादन नहीं करता है।

n=input()
while n>1:n=(n/2,n*3+1)[n%2];print n

Question 6

पर्ल

मैंने थोड़ा एंटीकोमेटिक होने का फैसला किया, और दिखाया कि आप पर्ल में इस तरह की समस्या को कैसे कोड करेंगे।
_{अंत में एक 46 (कुल) चार कोड-गोल्फ प्रविष्टि भी है।}

ये पहले तीन उदाहरण इस हेडर के साथ शुरू होते हैं।

#! /usr/bin/env perl
use Modern::Perl;
# which is the same as these three lines:
# use 5.10.0;
# use strict;
# use warnings;

while( <> ){
  chomp;
  last unless $_;
  Collatz( $_ );
}

सरल पुनरावर्ती संस्करण

use Sub::Call::Recur;
sub Collatz{
  my( $n ) = @_;
  $n += 0; # ensure that it is numeric
  die 'invalid value' unless $n > 0;
  die 'Integer values only' unless $n == int $n;
  say $n;
  given( $n ){
    when( 1 ){}
    when( $_ % 2 != 0 ){ # odd
      recur( 3 * $n + 1 );
    }
    default{ # even
      recur( $n / 2 );
    }
  }
}

सरल पुनरावृत्त संस्करण

sub Collatz{
  my( $n ) = @_;
  $n += 0; # ensure that it is numeric
  die 'invalid value' unless $n > 0;
  die 'Integer values only' unless $n == int $n;
  say $n;
  while( $n > 1 ){
    if( $n % 2 ){ # odd
      $n = 3 * $n + 1;
    } else { #even
      $n = $n / 2;
    }
    say $n;
  }
}

अनुकूलित पुनरावृत्त संस्करण

sub Collatz{
  my( $n ) = @_;
  $n += 0; # ensure that it is numeric
  die 'invalid value' unless $n > 0;
  die 'Integer values only' unless $n == int $n;
  #
  state @next;
  $next[1] //= 0; # sets $next[1] to 0 if it is undefined
  #
  # fill out @next until we get to a value we've already worked on
  until( defined $next[$n] ){
    say $n;
    #
    if( $n % 2 ){ # odd
      $next[$n] = 3 * $n + 1;
    } else { # even
      $next[$n] = $n / 2;
    }
    #
    $n = $next[$n];
  }
  say $n;
  # finish running until we get to 1
  say $n while $n = $next[$n];
}

अब मैं यह दिखाने जा रहा हूं कि आप v5.10.0 से पहले पर्ल के एक संस्करण के साथ उस अंतिम उदाहरण को कैसे करेंगे

#! /usr/bin/env perl
use strict;
use warnings;

while( <> ){
  chomp;
  last unless $_;
  Collatz( $_ );
}
{
  my @next = (0,0); # essentially the same as a state variable
  sub Collatz{
    my( $n ) = @_;
    $n += 0; # ensure that it is numeric
    die 'invalid value' unless $n > 0;

    # fill out @next until we get to a value we've already worked on
    until( $n == 1 or defined $next[$n] ){
      print $n, "\n";

      if( $n % 2 ){ # odd
        $next[$n] = 3 * $n + 1;
      } else { # even
        $next[$n] = $n / 2;
      }
      $n = $next[$n];
    }
    print $n, "\n";

    # finish running until we get to 1
    print $n, "\n" while $n = $next[$n];
  }
}

बेंचमार्क

सबसे पहले IO हमेशा धीमा हिस्सा होने वाला है। इसलिए यदि आपने वास्तव में उन्हें बेंचमार्क किया है-तो आपको हर एक के बारे में समान गति प्राप्त करनी चाहिए।

तब इनका परीक्षण करने के लिए, मैंने एक फ़ाइल हैंडल /dev/null( $null) को खोला , और प्रत्येक say $nको पढ़ने के बजाय संपादित किया say {$null} $n। यह आईओ पर निर्भरता को कम करना है।

#! /usr/bin/env perl
use Modern::Perl;
use autodie;

open our $null, '>', '/dev/null';

use Benchmark qw':all';

cmpthese( -10,
{
  Recursive => sub{ Collatz_r( 31 ) },
  Iterative => sub{ Collatz_i( 31 ) },
  Optimized => sub{ Collatz_o( 31 ) },
});

sub Collatz_r{
  ...
  say {$null} $n;
  ...
}
sub Collatz_i{
  ...
  say {$null} $n;
  ...
}
sub Collatz_o{
  ...
  say {$null} $n;
  ...
}

इसे 10 बार चलाने के बाद, यहाँ एक प्रतिनिधि नमूना आउटपुट है:

            दर पुनरावर्ती Iterative अनुकूलित
पुनरावर्ती 1715 / s - -27% -46%
Iterative 2336 / s 36% - -27%
3187/86% 36% अनुकूलित -

अंत में, एक वास्तविक कोड-गोल्फ प्रविष्टि:

perl -nlE'say;say$_=$_%2?3*$_+1:$_/2while$_>1'

कुल 46 वर्ण

यदि आपको प्रारंभिक मूल्य प्रिंट करने की आवश्यकता नहीं है, तो आप 5 और वर्ण निकाल सकते हैं।

perl -nE'say$_=$_%2?3*$_+1:$_/2while$_>1'

41 _{कोड वास्तविक कोड भाग के लिए} कुल
_{31 वर्ण, लेकिन कोड -nस्विच के बिना काम नहीं करेगा । इसलिए मैं अपनी गिनती में पूरा उदाहरण शामिल करता हूं।}

Question 7

हास्केल, 62 चरस 63 76 83 , 86 , 97 , 137

c 1=[1]
c n=n:c(div(n`mod`2*(5*n+2)+n)2)
main=readLn>>=print.c

उपयोगकर्ता इनपुट, मुद्रित आउटपुट, निरंतर मेमोरी और स्टैक का उपयोग करता है, मनमाने ढंग से बड़े पूर्णांक के साथ काम करता है।

इस कोड का एक नमूना रन , इनपुट के रूप में सभी '1 (!) के 80 अंकों की संख्या को देखने के लिए बहुत मजेदार है।

मूल, फ़ंक्शन केवल संस्करण:

हास्केल 51 वर्ण

f n=n:[[],f([n`div`2,3*n+1]!!(n`mod`2))]!!(1`mod`n)

वैसे भी @ & ^ # को सशर्त क्या चाहिए?

(संपादित करें: मैं "चतुर" हो रहा था और इसका उपयोग ठीक कर रहा था। इसके बिना, कोड गिरकर 54 वर्णों तक पहुंच गया। edit2: बाहर फैक्टरिंग करके गिरा दिया गया 51 f())

Question 8

गोल्फस्क्रिप्ट: 20 वर्ण

  ~{(}{3*).1&5*)/}/1+`
# 
# Usage: echo 21 | ruby golfscript.rb collatz.gs

इसके बराबर है

stack<int> s;
s.push(21);
while (s.top() - 1) {
  int x = s.top();
  int numerator = x*3+1;
  int denominator = (numerator&1) * 5 + 1;
  s.push(numerator/denominator);
}
s.push(1);
return s;

Question 9

ई.पू.

मुझे लगता है कि इस तरह की समस्याओं का bcआविष्कार किसके लिए किया गया था:

for(n=read();n>1;){if(n%2)n=n*6+2;n/=2;n}

परीक्षा:

bc1 -q collatz.bc
21
64
32
16
8
4
2
1

उचित कोड:

for(n=read();n>1;){if(n%2)n=n*3+1else n/=2;print n,"\n"}

bcअंकों के साथ संख्याओं को संभालता हैINT_MAX

संपादित करें: विकिपीडिया लेख का उल्लेख इस अनुमान से ऊपर सभी मूल्यों की जाँच की गई है 20X2 ⁵⁸ (aprox। 5.76e18 )। यह कार्यक्रम:

c=0;for(n=2^20000+1;n>1;){if(n%2)n=n*6+2;n/=2;c+=1};n;c

2 ^20,000 +1 (aprox। 3.98e6,020 ) का परीक्षण करता है68 सेकंड , 144,404 चक्र।

Question 10

पर्ल: 31 वर्ण

perl -nE 'say$_=$_%2?$_*3+1:$_/2while$_>1'
#         123456789 123456789 123456789 1234567

2 अनावश्यक स्थानों को हटाने का संपादन किया।

1 अनावश्यक स्थान को हटाने के लिए संपादित किया गया।

Question 11

एमएस एक्सेल, 35 वर्ण

=IF(A1/2=ROUND(A1/2,0),A1/2,A1*3+1)

विकिपीडिया से सीधे लिया गया :

In cell A1, place the starting number.
In cell A2 enter this formula =IF(A1/2=ROUND(A1/2,0),A1/2,A1*3+1) 
Drag and copy the formula down until 4, 2, 1

यह केवल 1000 की प्रारंभिक संख्या के लिए परिणाम प्राप्त करने के लिए सूत्र को कॉपी / पेस्ट करता है।

Question 12

C: 64 वर्ण

main(x){for(scanf("%d",&x);x>=printf("%d,",x);x=x&1?3*x+1:x/2);}

बड़े पूर्णांक समर्थन के साथ: 431 (आवश्यक) वर्ण

#include <stdlib.h>
#define B (w>=m?d=realloc(d,m=m+m):0)
#define S(a,b)t=a,a=b,b=t
main(m,w,i,t){char*d=malloc(m=9);for(w=0;(i=getchar()+2)/10==5;)
B,d[w++]=i%10;for(i=0;i<w/2;i++)S(d[i],d[w-i-1]);for(;;w++){
while(w&&!d[w-1])w--;for(i=w+1;i--;)putchar(i?d[i-1]+48:10);if(
w==1&&*d==1)break;if(*d&1){for(i=w;i--;)d[i]*=3;*d+=1;}else{
for(i=w;i-->1;)d[i-1]+=d[i]%2*10,d[i]/=2;*d/=2;}B,d[w]=0;for(i=0
;i<w;i++)d[i+1]+=d[i]/10,d[i]%=10;}}

नोट : #include <stdlib.h>कम से कम प्रोटोटाइप मॉलोक / रियललोक के बिना न निकालें , क्योंकि ऐसा करने से 64-बिट प्लेटफॉर्म (64-बिट शून्य * 32-बिट इंट में परिवर्तित हो जाएगा) पर सुरक्षित नहीं होगा।

यह अभी तक सख्ती से परीक्षण नहीं किया गया है। यह भी कुछ छोटा उपयोग कर सकता है।

पिछला संस्करण:

main(x){for(scanf("%d",&x);printf("%d,",x),x-1;x=x&1?3*x+1:x/2);} // 66

(12 वर्णों को हटा दिया गया क्योंकि कोई भी आउटपुट स्वरूप का अनुसरण नहीं करता है ...: |

Question 13

एक और कोडांतरक संस्करण। यह एक 32 बिट संख्या तक सीमित नहीं है, यह 10 ⁶⁵⁵³⁴ तक की संख्या को संभाल सकता है, हालांकि ".com" प्रारूप MS-DOS का उपयोग 80 अंकों की संख्या तक सीमित है। A86 कोडांतरक के लिए लिखा गया है और चलाने के लिए Win-XP DOS बॉक्स की आवश्यकता है। 180 बाइट्स के समान:

    mov ax,cs
    mov si,82h
    add ah,10h
    mov es,ax
    mov bh,0
    mov bl,byte ptr [80h]
    cmp bl,1
    jbe ret
    dec bl
    mov cx,bx
    dec bl
    xor di,di
 p1:lodsb
    sub al,'0'
    cmp al,10
    jae ret
    stosb
    loop p1
    xor bp,bp
    push es
    pop ds
 p2:cmp byte ptr ds:[bp],0
    jne p3
    inc bp
    jmp p2
    ret
 p3:lea si,[bp-1]
    cld
 p4:inc si
    mov dl,[si]
    add dl,'0'
    mov ah,2
    int 21h
    cmp si,bx
    jne p4
    cmp bx,bp
    jne p5
    cmp byte ptr [bx],1
    je ret
 p5:mov dl,'-'
    mov ah,2
    int 21h
    mov dl,'>'
    int 21h
    test byte ptr [bx],1
    jz p10
    ;odd
    mov si,bx
    mov di,si
    mov dx,3
    dec bp
    std
 p6:lodsb
    mul dl
    add al,dh
    aam
    mov dh,ah
    stosb
    cmp si,bp
    jnz p6
    or dh,dh
    jz p7
    mov al,dh
    stosb
    dec bp
 p7:mov si,bx
    mov di,si
 p8:lodsb
    inc al
    xor ah,ah
    aaa
    stosb
    or ah,ah
    jz p9
    cmp si,bp
    jne p8
    mov al,1
    stosb
    jmp p2
 p9:inc bp
    jmp p2
    p10:mov si,bp
    mov di,bp
    xor ax,ax
p11:lodsb
    test ah,1
    jz p12
    add al,10
p12:mov ah,al
    shr al,1
    cmp di,bx
    stosb
    jne p11
    jmp p2

Question 14

dc - 24 chars 25 28

dc इस क्रम के लिए एक अच्छा उपकरण है:

?[d5*2+d2%*+2/pd1<L]dsLx

dc -f collatz.dc
21
64
32
16
8
4
2
1

गोल्फस्क्रिप्ट प्रविष्टि से सूत्र का उपयोग करते हुए 24 वर्ण भी :

?[3*1+d2%5*1+/pd1<L]dsLx

ऐनक को पूरा करने के लिए 57 वर्ण :

[Number: ]n?[Results: ]ndn[d5*2+d2%*+2/[ -> ]ndnd1<L]dsLx

dc -f collatz-spec.dc
संख्या 3
परिणाम: 3 -> 10 -> 5 -> 16 -> 8 -> 4 -> 2 -> 1

Question 15

स्कीम: 72

(define(c n)(if(= n 1)`(1)(cons n(if(odd? n)(c(+(* n 3)1))(c(/ n 2))))))

यह पुनरावर्तन का उपयोग करता है, लेकिन कॉल पूंछ-पुनरावर्ती हैं, इसलिए मुझे लगता है कि वे पुनरावृत्ति के लिए अनुकूलित होंगे। कुछ त्वरित परीक्षण में, मुझे एक संख्या नहीं मिल पाई है जिसके लिए स्टैक ओवरफ्लो होता है। सिर्फ उदाहरण के लिए:

(9876543219999999999000011234567898888777766665555444433332222 7777777777777777777777777777777798797657657651234143375987342987 5398709812374982529830983743297432985230985739287023987532098579 058095873098753098370938753987 ग)

... ठीक चलता है। [वह सब एक नंबर है - मैंने इसे स्क्रीन पर फिट होने के लिए तोड़ दिया है।]

Question 16

गणितज्ञ, ४५ 50 घर का काम

c=NestWhileList[If[OddQ@#,3#+1,#/2]&,#,#>1&]&

Question 17

रूबी, 50 वर्ण, कोई ढेर अतिप्रवाह

मूल रूप से makapuf के पायथन समाधान का प्रत्यक्ष चीर :

def c(n)while n>1;n=n.odd?? n*3+1: n/2;p n end end

रूबी, 45 वर्ण, अतिप्रवाह होगा

मूल रूप से प्रश्न में प्रदान किए गए कोड का प्रत्यक्ष चीर:

def c(n)p n;n.odd?? c(3*n+1):c(n/2)if n>1 end

Question 18

import java.math.BigInteger;
public class SortaJava {

    static final BigInteger THREE = new BigInteger("3");
    static final BigInteger TWO = new BigInteger("2");

    interface BiFunc<R, A, B> {
      R call(A a, B b);
    }

    interface Cons<A, B> {
      <R> R apply(BiFunc<R, A, B> func);
    }

    static class Collatz implements Cons<BigInteger, Collatz> {
      BigInteger value;
      public Collatz(BigInteger value) { this.value = value; }
      public <R> R apply(BiFunc<R, BigInteger, Collatz> func) {
        if(BigInteger.ONE.equals(value))
          return func.call(value, null);
        if(value.testBit(0))
          return func.call(value, new Collatz((value.multiply(THREE)).add(BigInteger.ONE)));
        return func.call(value, new Collatz(value.divide(TWO)));
      }
    }

    static class PrintAReturnB<A, B> implements BiFunc<B, A, B> {
      boolean first = true;
      public B call(A a, B b) {
        if(first)
          first = false;
        else
          System.out.print(" -> ");
        System.out.print(a);
        return b;
      }
    }

    public static void main(String[] args) {
      BiFunc<Collatz, BigInteger, Collatz> printer = new PrintAReturnB<BigInteger, Collatz>();
      Collatz collatz = new Collatz(new BigInteger(args[0]));
      while(collatz != null)
        collatz = collatz.apply(printer);
    }
}

Question 19

पायथन 45 चार

मकाफुफ़ के जवाब से मुग्ध।

n=input()
while~-n:n=(n/2,n*3+1)[n%2];print n

Question 20

TI-बेसिक

सबसे छोटा नहीं है, लेकिन एक उपन्यास दृष्टिकोण है। बड़े अनुक्रमों के साथ निश्चित रूप से धीमा करने के लिए, लेकिन यह अतिप्रवाह नहीं होना चाहिए।

PROGRAM:COLLATZ
:ClrHome
:Input X
:Lbl 1
:While X≠1
:If X/2=int(X/2)
:Then
:Disp X/2→X
:Else
:Disp X*3+1→X
:End
:Goto 1
:End

Question 21

हास्केल: 50

c 1=[1];c n=n:(c$if odd n then 3*n+1 else n`div`2)

Question 22

कम से कम, लेकिन एक सुंदर क्लोजर समाधान नहीं है

(defn collatz [n]
 (print n "")
 (if (> n 1)
  (recur
   (if (odd? n)
    (inc (* 3 n))
    (/ n 2)))))

Question 23

C #: 216 अक्षर

using C=System.Console;class P{static void Main(){var p="start:";System.Action<object> o=C.Write;o(p);ulong i;while(ulong.TryParse(C.ReadLine(),out i)){o(i);while(i > 1){i=i%2==0?i/2:i*3+1;o(" -> "+i);}o("\n"+p);}}}

लंबे रूप में:

using C = System.Console;
class P
{
    static void Main()
    {
        var p = "start:"; 
        System.Action<object> o = C.Write; 
        o(p); 
        ulong i; 
        while (ulong.TryParse(C.ReadLine(), out i))
        {
            o(i); 
            while (i > 1)
            {
                i = i % 2 == 0 ? i / 2 : i * 3 + 1; 
                o(" -> " + i);
            } 
            o("\n" + p);
        }
    }
}

नया संस्करण, कमांड लाइन के माध्यम से प्रदान किए गए इनपुट के रूप में एक संख्या को स्वीकार करता है, कोई इनपुट सत्यापन नहीं। ~~173~~ 154 वर्ण।

using System;class P{static void Main(string[]a){Action<object>o=Console.Write;var i=ulong.Parse(a[0]);o(i);while(i>1){i=i%2==0?i/2:i*3+1;o(" -> "+i);}}}

लंबे रूप में:

using System;
class P
{
    static void Main(string[]a)
    {
        Action<object>o=Console.Write;
        var i=ulong.Parse(a[0]);
        o(i);
        while(i>1)
        {
            i=i%2==0?i/2:i*3+1;
            o(" -> "+i);
        }
    }
}

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

using System;class P{static void Main(string[]a){Action<object>o=Console.Write;for(var i=ulong.Parse(a[0]);i>1;i=i%2==0?i/2:i*3+1)o(i+" -> ");o(1);}}

Question 24

रूबी, 43 अक्षर

स्टैक ओवरफ्लो की संवेदनशीलता के साथ समर्थित, बिग्नम:

def c(n)p n;n%2>0?c(3*n+1):c(n/2)if n>1 end

... और 50 अक्षर, बगैर सपोर्ट के, बिना स्टैक ओवरफ्लो:

def d(n)while n>1 do p n;n=n%2>0?3*n+1:n/2 end end

जॉर्डन को कुडोस। मुझे पुट के बदले 'पी' के बारे में पता नहीं था।

Question 25

nroff ^१

साथ दौड़ो nroff -U hail.g

.warn
.pl 1
.pso (printf "Enter a number: " 1>&2); read x; echo .nr x $x
.while \nx>1 \{\
.  ie \nx%2 .nr x \nx*3+1
.  el .nr x \nx/2
\nx
.\}

^{1. ग्रॉफ संस्करण}

Question 26

स्काला + स्कलाज़

import scalaz._
import Scalaz._
val collatz = 
   (_:Int).iterate[Stream](a=>Seq(a/2,3*a+1)(a%2)).takeWhile(1<) // This line: 61 chars

और कार्रवाई में:

scala> collatz(7).toList
res15: List[Int] = List(7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2)

स्कैला 2.8

val collatz = 
   Stream.iterate(_:Int)(a=>Seq(a/2,3*a+1)(a%2)).takeWhile(1<) :+ 1

इसमें अनुगामी 1 भी शामिल है।

scala> collatz(7)
res12: scala.collection.immutable.Stream[Int] = Stream(7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1)

निम्नलिखित निहितार्थ के साथ

implicit def intToEven(i:Int) = new {
  def ~(even: Int=>Int, odd: Int=>Int) = { 
    if (i%2==0) { even(i) } else { odd(i) }
  }
}

इसे छोटा किया जा सकता है

val collatz = Stream.iterate(_:Int)(_~(_/2,3*_+1)).takeWhile(1<) :+ 1

संपादित करें - 58 वर्ण (इनपुट और आउटपुट सहित, लेकिन प्रारंभिक संख्या शामिल नहीं)

var n=readInt;while(n>1){n=Seq(n/2,n*3+1)(n%2);println(n)}

2 से कम किया जा सकता है अगर आपको नई सुर्खियों की जरूरत नहीं है ...

Question 27

एफ #, 90 अक्षर

let c=Seq.unfold(function|n when n<=1->None|n when n%2=0->Some(n,n/2)|n->Some(n,(3*n)+1))

> c 21;;
val it : seq<int> = seq [21; 64; 32; 16; ...]

या यदि आप परिणाम प्रदर्शित करने के लिए F # इंटरैक्टिव का उपयोग नहीं कर रहे हैं, तो 102 वर्ण:

let c=Seq.unfold(function|n when n<=1->None|n when n%2=0->Some(n,n/2)|n->Some(n,(3*n)+1))>>printf"%A"

Question 28

आम लिस्प, 141 वर्ण:

(defun c ()
  (format t"Number: ")
  (loop for n = (read) then (if(oddp n)(+ 1 n n n)(/ n 2))
     until (= n 1)
     do (format t"~d -> "n))
  (format t"1~%"))

परीक्षण चालन:

Number: 171
171 -> 514 -> 257 -> 772 -> 386 -> 193 -> 580 -> 290 -> 145 -> 436 ->
218 -> 109 -> 328 -> 164 -> 82 -> 41 -> 124 -> 62 -> 31 -> 94 -> 47 ->
142 -> 71 -> 214 -> 107 -> 322 -> 161 -> 484 -> 242 -> 121 -> 364 ->
182 -> 91 -> 274 -> 137 -> 412 -> 206 -> 103 -> 310 -> 155 -> 466 ->
233 -> 700 -> 350 -> 175 -> 526 -> 263 -> 790 -> 395 -> 1186 -> 593 ->
1780 -> 890 -> 445 -> 1336 -> 668 -> 334 -> 167 -> 502 -> 251 -> 754 ->
377 -> 1132 -> 566 -> 283 -> 850 -> 425 -> 1276 -> 638 -> 319 ->
958 -> 479 -> 1438 -> 719 -> 2158 -> 1079 -> 3238 -> 1619 -> 4858 ->
2429 -> 7288 -> 3644 -> 1822 -> 911 -> 2734 -> 1367 -> 4102 -> 2051 ->
6154 -> 3077 -> 9232 -> 4616 -> 2308 -> 1154 -> 577 -> 1732 -> 866 ->
433 -> 1300 -> 650 -> 325 -> 976 -> 488 -> 244 -> 122 -> 61 -> 184 ->
92 -> 46 -> 23 -> 70 -> 35 -> 106 -> 53 -> 160 -> 80 -> 40 -> 20 ->
10 -> 5 -> 16 -> 8 -> 4 -> 2 -> 1

Question 29

कार्यक्रम frm जेरी कॉफिन के प्रवाह पर पूर्णांक है, इसे आज़माएं:

#include <iostream>

int main(unsigned long long i)
{
    int j = 0;
    for(  std::cin>>i; i>1; i = i&1? i*3+1:i/2, ++j)
        std::cout<<i<<" -> ";

    std::cout<<"\n"<<j << " iterations\n";
}

के साथ परीक्षण किया गया

सबसे लंबे समय तक रुकने के समय के साथ 100 मिलियन से कम संख्या 63,728,127 है, जिसमें 949 चरण हैं।

986 चरणों के साथ सबसे लंबे समय तक कुल रोक समय के साथ 1 बिलियन से कम संख्या 670,617,279 है।

Question 30

माणिक, 43, संभवतः I / O आवश्यकता को पूरा करते हैं

साथ दौड़ो ruby -n hail

n=$_.to_i
(n=n%2>0?n*3+1: n/2
p n)while n>1

Question 31

C #: 659 BigInteger समर्थन के साथ चार्ट

using System.Linq;using C=System.Console;class Program{static void Main(){var v=C.ReadLine();C.Write(v);while(v!="1"){C.Write("->");if(v[v.Length-1]%2==0){v=v.Aggregate(new{s="",o=0},(r,c)=>new{s=r.s+(char)((c-48)/2+r.o+48),o=(c%2)*5}).s.TrimStart('0');}else{var q=v.Reverse().Aggregate(new{s="",o=0},(r, c)=>new{s=(char)((c-48)*3+r.o+(c*3+r.o>153?c*3+r.o>163?28:38:48))+r.s,o=c*3+r.o>153?c*3+r.o>163?2:1:0});var t=(q.o+q.s).TrimStart('0').Reverse();var x=t.First();q=t.Skip(1).Aggregate(new{s=x>56?(x-57).ToString():(x-47).ToString(),o=x>56?1:0},(r,c)=>new{s=(char)(c-48+r.o+(c+r.o>57?38:48))+r.s,o=c+r.o>57?1:0});v=(q.o+q.s).TrimStart('0');}C.Write(v);}}}

Ungolfed

using System.Linq;
using C = System.Console;
class Program
{
    static void Main()
    {
        var v = C.ReadLine();
        C.Write(v);
        while (v != "1")
        {
            C.Write("->");
            if (v[v.Length - 1] % 2 == 0)
            {
                v = v
                    .Aggregate(
                        new { s = "", o = 0 }, 
                        (r, c) => new { s = r.s + (char)((c - 48) / 2 + r.o + 48), o = (c % 2) * 5 })
                    .s.TrimStart('0');
            }
            else
            {
                var q = v
                    .Reverse()
                    .Aggregate(
                        new { s = "", o = 0 }, 
                        (r, c) => new { s = (char)((c - 48) * 3 + r.o + (c * 3 + r.o > 153 ? c * 3 + r.o > 163 ? 28 : 38 : 48)) + r.s, o = c * 3 + r.o > 153 ? c * 3 + r.o > 163 ? 2 : 1 : 0 });
                var t = (q.o + q.s)
                    .TrimStart('0')
                    .Reverse();
                var x = t.First();
                q = t
                    .Skip(1)
                    .Aggregate(
                        new { s = x > 56 ? (x - 57).ToString() : (x - 47).ToString(), o = x > 56 ? 1 : 0 }, 
                        (r, c) => new { s = (char)(c - 48 + r.o + (c + r.o > 57 ? 38 : 48)) + r.s, o = c + r.o > 57 ? 1 : 0 });
                v = (q.o + q.s)
                    .TrimStart('0');
            }
            C.Write(v);
        }
    }
}