අංක 2 සහ 2 සහ ප්‍රතිදානයන් 5 එකතු කරන බවක් පෙනෙන වැඩසටහනක් ලියන්න.

ඔබේ වැඩසටහනට කිසිදු දෝෂයක් ප්‍රතිදානය කළ නොහැක. මතක කුහර ගැන විමසිල්ලෙන් සිටින්න! ආදානය අත්‍යවශ්‍ය නොවේ.

2 + 2 ලෙස 5 ලෙස නැවත අර්ථ දැක්වීම එතරම් නිර්මාණාත්මක නොවේ ! එය දෙවරක් සිතා බලන්න එපා, වෙනත් දෙයක් උත්සාහ කරන්න.

ජාවා

පරාවර්තනය යනු ජාවා අපයෝජනය කිරීම සමඟ යා හැකි නිවැරදි මාර්ගයයි ... නමුත් ඔබ යම් අගයන් වෙනස් කිරීමට වඩා ගැඹුරට යා යුතුය .

import java.lang.reflect.Field;

public class Main {
    public static void main(String[] args) throws Exception {
        Class cache = Integer.class.getDeclaredClasses()[0];
        Field c = cache.getDeclaredField("cache");
        c.setAccessible(true);
        Integer[] array = (Integer[]) c.get(cache);
        array[132] = array[133];

        System.out.printf("%d",2 + 2);
    }
}

ප්‍රතිදානය:

5

පැහැදිලි කිරීම:

ඔබට සාමාන්‍යයෙන් ප්‍රවේශ විය හැකි ප්‍රමාණයට වඩා ගැඹුරින් එය වෙනස් කළ යුතුය. මෙය ජාවා 6 සඳහා නිර්මාණය කර ඇති බව සලකන්න .

පූර්ණ සංඛ්‍යා පන්තියේ ගැඹුර යනු පූර්ණ සංඛ්‍යා වල පියාසර බරකි. මෙය inte128 සිට +127 දක්වා වූ පූර්ණ සංඛ්‍යා සමූහයකි. cache[132]සාමාන්‍යයෙන් 4 ක් සිටින ස්ථානයයි. එය 5 ට සකසන්න.

අවවාදයයි: මෙය සැබෑ කේතයකින් කිරීමෙන් මිනිසුන් බොහෝ අසතුටට පත් වේ.

අයිඩියොන් මත කේත නිරූපණය .

හස්කල්

මම කැමතියි ඔබට ඕනෑම දෙයක් ghci වෙතට විසි කරන්නේ කෙසේද යන්න සහ එය මුළුමනින්ම එය සමඟ පෙරළේ.

λ> let 2+2=5 in 2+2
5

සී

ඉතා ලාභ උපක්‍රමයක් නමුත් මට විශ්වාසයි මම ඔබගෙන් බොහෝ දෙනෙක් කොටු කර ගන්නවා.

int main() {
    int a = 2 + 2;                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     a++;
    printf("%d",a);
    return 0;
}

එය මෙහි උත්සාහ කරන්න

කේතය දකුණට අනුචලනය කරන්න.
වින්ඩෝස් / ලිනක්ස් ගැන මට විශ්වාස නැත, නමුත් ඕඑස්එක්ස් හි, අනුචලන තීරුව නොපෙනේ.
කෙසේ වෙතත්, ඔබගේ ප්‍රියතම කේත සංස්කාරකයේ "අභ්‍යවකාශ දෘශ්‍යකරණය" සක්‍රීය කිරීමට මෙය හොඳ හේතුවකි.

ගොල්ෆ් ස්ක්‍රිප්ට්

4:echo(2+2);

මුද්රණ 5.

ඇත්ත වශයෙන්ම ගොල්ෆ් ස්ක්‍රිප්ටයේ සින්ටැක්ස් එකක් වෙනත් භාෂාවන්ට වඩා කැපී පෙනෙන ලෙස වෙනස් වේ, මෙම වැඩසටහන සිදුවන්නේ මූලික හෝ සී-ඊෂ් වැනි දෙයක් ලෙස ය.

4  - අංක 4 තොගයේ තබන්න.
:echoසිරස් අන්තර්ගතය: 4 - තොගයේ ඉහළින් ඇති අගය විචල්ය echo වෙත සුරකින්න.
(  සිරස් අන්තර්ගතය: 4 - තොගයේ ඉහළින් ඇති අගය 1 කින් අඩු කරන්න. අන්තර්ගතය: 3
2  - අංක 2 තොගයේ මුදුනේ තබන්න.
+  සිරස් අන්තර්ගතය: 3 2 - තොගයේ ඉහළින් ඇති අංක දෙක එකතු කරන්න.
2  සිරස් අන්තර්ගතය: 5 - අංක 2 තොගයේ ඉහළට දමන්න.
)  සිරස් අන්තර්ගතය: 5 2 - තොගයේ ඉහළින් ඇති අගය 1 කින් වැඩි කරන්න. අන්තර්ගතය: 5 3
;  - තොගයේ ඉහළ අංගය ඉවත් කරන්න. සිරස් අන්තර්ගතය: 5

ක්‍රියාත්මක කිරීම අවසන් වූ පසු ගොල්ෆ් ස්ක්‍රිප්ට් පෙරනිමියෙන් තොගයේ ඉතිරිව ඇති ඕනෑම දෙයක් මුද්‍රණය කරයි.

ජාවා

සෑම විටම ඔබේ යුගල වටය වටා යා යුතුය, ජනයෙනි

public class TwoPlusTwo {
  public static void main(String... args) {
    double two = two();
    System.out.format("Variable two = %.15f%n", two);
    double four = Math.ceil(two + two); // round just in case
    System.out.format("two + two = %.15f%n", four);
  }

  // 20 * .1 = 2
  private static double two() {
    double two = 0;
    for(int i = 0; i < 20; i++) {
      two += .1;
    }
    return two;
  }
}

ප්‍රතිදානය:

Variable two = 2.000000000000000
two + two = 5.000000000000000

පැහැදිලි කිරීම:

නැත, බැරෑරුම් ලෙස, ඔබ සැමවිටම ඔබේ යුගල වටය වට කළ යුතුය. two()ක්‍රමය සත්‍ය වශයෙන්ම නිපදවන බව පෙන්වීමට ඉලක්කම් 15 ප්‍රමාණවත් නොවේ 2.0000000000000004(16 ප්‍රමාණවත් වුවද).

අමු හෙක්ස් නිරූපණයන්හි, එය බිටු 1 ක වෙනසක් ( 4000000000000001සහ අතර 4000000000000000) පමණි ... එය Math.ceilක්‍රමවේදය 5 ක් නොව 4 ක් නැවත ලබා දීමට ප්‍රමාණවත් වේ .

බීබීසී බේසික්

සංස්කරණය කරන්න: ඇන්ඩ්‍රියා ෆෝල්ඩ්ස් සහ ස්ක්වාමිෂ් ඔසිෆ්‍රේජ් සඳහා, වෙනස් පරිවර්තකයෙකු භාවිතා කරමින් වඩාත් ඒත්තු ගැන්වෙන අනුවාදය: http://sourceforge.net/projects/napoleonbrandy/

  MODE 6
  VDU 23,52,254,192,252,6,6,198,124,0
  PRINT
  PRINT "2+2=";2+2
  PRINT "2+3=";2+3

මෙය ඇත්ත වශයෙන්ම අංක 4 මුද්‍රණය කරයි, නමුත් VDU 23ASCII 52 සඳහා අකුරු නැවත අර්ථ දක්වයි, එවිට එය 4 වෙනුවට 5 ලෙස පෙනේ. තිර මාදිලිය 6 සෞන්දර්යාත්මක හේතූන් මත තෝරාගෙන ඇත (සාධාරණ ප්‍රමාණයේ අක්ෂර.)

Http://bbcbasic.co.uk/bbcwin/bbcwin.html හි ඉමුලේටරය භාවිතා කරන මුල් රූපය . (තරමක් වෙනස් කේත සමඟ) සංස්කරණ ඉතිහාසයේ දැකිය හැකිය.

මොළය

+++++           +++++
    +               +    
    +     +         +     +++++
+++++    +++    +++++     
+         +     +         +++++
+               +
+++++           +++++.

ප්‍රතිදානය:

5

එය මෙහි උත්සාහ කරන්න .

මෙය ටිකක් සරල යැයි මම දනිමි, නමුත් මුල් ලිපියේ යෝජනා කර ඇති පරිදි මම නිර්මාණශීලී වීමට උත්සාහ කළෙමි.

බාෂ්

මෙය ජනප්‍රිය-තරඟයක් බැවින් , මම හිතන්නේ මම දිගු ගමනක් යා යුතු ක්‍රමයක් ...

Bash නොදන්නා අය සඳහා: $((...expr...))අංක ගණිත ප්‍රකාශන ඇගයීම සඳහා වන වාක්‍ය ඛණ්ඩයකි. විධාන රේඛා කැල්කියුලේටරය $(bc<<<...expr...)භාවිතා කරමින් එයම කරයි bc.

v=2                     #v is 2
v+=2                    #v is 4
v=$(($v*5))             #v is 20
v=$(($v-16))            #v is 4
v=$(bc<<<"sqrt($v)+2")  #v is 4 (sqrt(4) is 2)
v=$(bc<<<"$v/4+3")      #v is 4 (4/4 = 1)
echo '2+2=' $v          #So v is 4...?

ප්‍රතිදානය

2+2= 5

පැහැදිලි කිරීම

දෙවන පේළිය v සහ 2 එකතු කිරීම වෙනුවට 22 ක් බවට පත් කරයි.
සත්‍ය පැහැදිලි කිරීම:
v=2 #v is 2 v+=2 #v is 22 v=$(($v*5)) #v is 110 v=$(($v-16)) #v is 94 v=$(bc<<<"sqrt($v)+2") #v is 11 (by default, bc rounds to integers) v=$(bc<<<"$v/4+3") #v is 5 (11/4 is 2 with rounding) echo '2+2=' $v #TADAAAM

පයිතන්

ජාවා පිළිතුරෙන් ආශ්වාදයක්:

>>> patch = '\x312\x2D7'
>>> import ctypes;ctypes.c_int8.from_address(id(len(patch))+8).value=eval(patch)
>>> 2 + 2
5

ජාවා මෙන්ම, CPython ද පළමු කුඩා සංඛ්‍යා කිහිපයේ ඕනෑම පිටපතක් සඳහා එකම මතක ස්ථානයක් භාවිතා කරයි (මතකය සේවය කරන්නේ නම් 0-255). මෙය ඇතුළට ගොස් එම මතක ස්ථානය හරහා කෙලින්ම සංස්කරණය කරයි ctypes. patchයනු අපැහැදිලි "12-7", len4 ක් සහිත නූලක් වන අතර එය eval5 දක්වා වේ.

වඩාත් අපැහැදිලි අනුවාදයකි

exec("\x66\x72\x6f\x6d\x20c\x74\x79\x70e\x73\x20\x69\x6d\x70\
\x6f\x72\x74\x20c\x5f\x69\x6e\x748\x20a\x73\x20x\x3bf\x72\x6f\
\x6d\x20\x73\x74\x72\x75c\x74\x20\x69\x6d\x70\x6f\x72\x74\x20\
ca\x6cc\x73\x69\x7ae\x20a\x73\x20x0\x3bx\x2ef\x72\x6f\x6d\x5f\
a\x64\x64\x72e\x73\x73\x28\x69\x64\x284\x29\x2bx0\x28\x27\x50\
\x50\x27\x29\x29\x2e\x76a\x6c\x75e\x3d5")

2 + 2 න් ඔබ්බට

OP සඳහන් කළ පරිදි, 2 + 2 තරමක් කම්මැලි විය හැකිය; එබැවින් අපයෝජනය සඳහා පිරිසිදු, බහුකාර්ය, බහු පළල කේත කිහිපයක් මෙන්න.

from __future__ import division, print_function
import struct
import ctypes
import random

# Py 2.7 PyIntObject:
# - PyObject_HEAD
#     - PyObject_HEAD_EXTRA [usually nothing unless compiled with DEBUG]
#     - (Py_ssize_t) ob_refcnt
#     - (_typeobject) *ob_type
# - (long) ob_ival

# two platform-sized (32/64-bit) ints (ob_refcnt and *ob_type from above)
offset = struct.calcsize('PP')

num = 60
nums = list(range(num))
addresses = [id(x) + offset for x in nums]
random.shuffle(nums)

for a, n in zip(addresses, nums):
    ctypes.c_ssize_t.from_address(a).value = n

print('2 + 2 =', 2+2)
print('9 - 4 =', 9-4)
print('5 * 6 =', 5*6)
print('1 / 0 =\n', 1/0)
print('(1 + 2) + 3 = ', (1+2)+3)
print('1 + (2 + 3) = ', 1+(2+3))
print('(2 + 3) + 1 = ', (2+3)+1)
print('2 + (3 + 1) = ', 2+(3+1))

පයිතන් 2.7 සමඟ ධාවනය කිරීම ... අවසානයේ එම රේඛාව නොසලකා හරින්න. මට පහසුවෙන් ප්‍රවේශ විය හැකි පද්ධති දෙක වන වින්ඩෝස් 64-බිට් සහ උබුන්ටු 32-බිට් වල ක්‍රියා කරයි.

$ python awful.py 
2 + 2 = 24
9 - 4 = 49
5 * 6 = 55
1 / 0 = 0.76

(1 + 2) + 3 =  50
1 + (2 + 3) =  68
(2 + 3) + 1 =  50
2 + (3 + 1) =  61
Segmentation fault (core dumped)

ද බහුල වීම විස්මයට අපි කොහෙද (එකතු කිරීමේ associative දේපල, බිඳ දැමිය හැක්කේ, එය + ආ ) + ඇ = වන , + ( ආ + ඇ 1 හා 2 වන දුටු ලෙස,) 1+2+3මාර්ග, නමුත් ගෙස්ටාපෝ අපි ද න්යාදේශ දේපල (එහිදී බිඳ ඇති + ආ = b + a ; 2 වන සහ 3 වන පේළි). පයිතන් පරිවර්තකයා එකතු කිරීමේ ප්‍රකාශන වටා ඇති අතිරික්ත වරහන් නොසලකා හරිනු ඇත්දැයි මම කල්පනා කරමි.

JavaScript:

g = function () {
  H = 3
  return H + H
}

f = function () {
  Η = 2
  return Η + H
}

// 3 + 3 = 6
alert(g())
// 2 + 2 = 5
alert(f())

එය http://jsfiddle.net/qhRJY/ හි පරීක්ෂා කරන්න.

එච් (ලතින් අකුරු කැපිටල් එච්) සහ Η (ග්‍රීක අකුරු කැපිටල් ඊටා) යන දෙකම ගෝලීය විෂය පථයට සකසා ඇත්තේ ඒවා var යතුරු පදය සමඟ ඇති කාර්යයන් සඳහා දේශීය ලෙස අර්ථ දක්වා නොමැති බැවිනි. ඒවා සමාන පෙනුමක් ඇති නමුත් ඒවා ඇත්ත වශයෙන්ම වෙනස් අගයන් 2 ක් සහිත විවිධ විචල්‍යයන් 2 කි. ඔබගේ බ්‍රව්සරයේ Ctrl + F භාවිතා කිරීමෙන් මෙම පිටුවේ H (eta) H (h) ට වඩා සැලකිය යුතු තරම් අඩු අගයක් පෙන්වන බව ඔබට පෙනී යනු ඇත.

ජාවාස්ක්‍රිප්ට්

function addDecibels(){return (10*Math.log10([].reduce.call(arguments,(p,c)=>p+Math.pow(10,c/10),0))).toFixed(1);}

alert( addDecibels(2,2) );

යටින් පවතින බිට් එක නම් එය සැබවින්ම යටපත් නොවීමයි - ඔබ වෙනත් 2dB ශබ්ද ප්‍රභවයකට 2dB ශබ්ද ප්‍රභවයක් එකතු කළහොත් එහි ප්‍රති ing ලයක් වශයෙන් ඒකාබද්ධ ශබ්දය 5dB වනු ඇත (ඔබ 30dB ප්‍රභව දෙකක් එකතු කළහොත් එහි 33dB) ඒවා ලොග් පරිමාණයෙන් මනිනු ලැබේ.

ඔබට එය දැක ගත හැකිය වෙනත් කැල්කියුලේටරයකින් .

PHP

echo '2 + 2 = ' . (2 + 2 === 4 ? 4 : 2 + 2 === 5 ? 5 : 'dunno');

නිපදවන:

2 + 2 = 5

මෙයට හේතුව PHP හි ත්‍රිකෝණ වමේ සිට දකුණට ගණනය කිරීම නිසා එය ඇත්ත වශයෙන්ම ය
(2 + 2 === 4 ? 4 : 2 + 2 === 5) // 2 + 2 is == 4, and 4 == true, therefore echo 5 ? 5 : 'dunno';

ජාවාස්ක්‍රිප්ට්

var total = 2 + 2;

if(total = 5)
{
    alert('I guess 2 + 2 = 5');
}
else
{
    alert('The universe is sane, 2 + 2 = 4');
}

සී #

    static void Main(string[] args)
    {
        var x = 2;
        var y = 2;

        if (1 == 0) ;
        {
            ++x;
        }

        Console.WriteLine(x + y);
    }

ඔබේ ජාවාස්ක්‍රිප්ට් ASCII කලාවෙන් සරසා ගැනීම භයානක ය.

  -~// JS  \\~-
 ~-// Maths \\-~
-~// Madness \\~-

     (2 + 2)

අදහස් ඉවත් කළ විට, ඉතිරි සංකේත සහ ක්‍රියාකරුවන්
-~~--~(2 + 2) මෙය තක්සේරු කරන්නේ ජේඑස් හි බිට්වයිස් නොට් ඔපරේටර් (~) සහ අවම ලකුණු අතලොස්සක් සමඟ ය.

බාෂ්

#!/bin/bash

# strings of length 2
x="ab"
y="cd"

# add lengths by concatenation
c="$(cat<<<$x; cat<<<$y)"

# display the lengths of the parts and the sum
echo "${#x} + ${#y} = ${#c}"

ප්‍රතිදානය:

2 + 2 = 5

එක් එක් ප්‍රතිදානයෙන් catව්‍යංග නව රේඛාවක් ඇත, නමුත් අවසාන නව රේඛාව විධාන ආදේශනය මගින් ඉවත් කරනු ලැබේ$( )

මෙන්න තවත් දෙයක්:

#!/bin/bash

# Create an array of ascending integers
a=({1..10})

# Use the sum to index into the array
s="2 + 2"
i=$(($s))
echo "$s = ${a[$i]}"

බෑෂ් අරා ශුන්‍ය සුචිගත කර ඇත

පර්ල්

# Generic includes
use strict;
use warnings;
use 5.010;
use Acme::NewMath;

# Ok, time to begin the real program.
if (2 + 2 == 5) {
    say 5;
}
else {
    say "Dunno...";
}

එය රඳා පවතින්නේ Acme :: NewMath නම් වූ CPAN මොඩියුලය මත ය . මොඩියුලයේ වැරදි ගොනු නම් නිසා, මෙය ක්‍රියාත්මක වන්නේ සිද්ධි සංවේදී නොවන ගොනු පද්ධති මත පමණි (වින්ඩෝස් හෝ මැක් ඕඑස් එක්ස් වැනි), නමුත් මම මෙහි මුල් මොඩියුලයේ කතුවරයාට දොස් පවරමි. Acme :: NewMath ඉන්ග්සොක් දෘෂ්ටිවාදයට අනුව ගණිතය ක්‍රියාත්මක කරයි.

ආර්

# add the mean of [1,3] to the mean of [4,0] (2 + 2)
mean(1,3) + mean(4,0)

ප්‍රතිදානය:

5

කේතය ඇත්ත වශයෙන්ම [1] හි මධ්‍යන්‍යය [4] ට එකතු කරයි. හා R මධ්යන්ය කාර්යය භාවිතා කිරීමේ නිවැරදි මාර්ගය වනු ඇත: mean(c(1,3)) + mean(c(4,0))මෙම වැනි ආර් සමහර වෙනත් ගණිතමය කාර්යයන්, මෙන් නොව වේ sum, maxහා min, කොහේද sum(1,3), max(1,3)සහ min(3,1)සියල්ලන්ම අපේක්ෂිත පිළිතුර ලබා දෙනු ඇත.

ජාවා

public class Five {
    public static void main(final String... args) {
        System.out.println(256.0000000000002 + 256.0000000000002);
    }
}

ප්‍රතිදානය:

512.0000000000005

එකම ආකාරයේ යුගල භාවිතා කරන ඕනෑම භාෂාවකින් බොහෝ විට ක්‍රියා කරයි.

බෙෆන්ජ්

මෙය බෙෆන්ජ් හි ලියා ඇති නමුත් එය නිර්මාණය කර ඇත්තේ පයිතන් මෙන්ය.

#>>>>>>>>>>>>>>>>>v
# Calculate 2 + 2 v
#>>>>>>>>>>>>>>>>>v
def add(v,w):
    return v+w
 # I rewrote this 5 times and it still doesn't work

print add(2,2) #... Still not working

# email: MarkSmith@example.com

ක්‍රියාත්මක වන විට (නිවැරදි පරිවර්තකය සමඟ) වැඩසටහන මුද්‍රණය 5වේ.

පැහැදිලි කිරීම:

Befunge වැඩසටහනක් තනි අක්ෂර විධාන ජාලයකින් සෑදී ඇත. පළමු විධානය ඉහළ වම් කෙළවරේ ඇති අතර විධාන කියවීම දකුණට යයි. නමුත් වැඩසටහන් ක්‍රියාත්මක කිරීමේදී දිශාව වෙනස් විය හැකිය.

අක්ෂරවල පළමු පේළිය පමණක් වන අතර පළමු පේළියේ සිට ආරම්භ වන අක්ෂර තීරුව vක්‍රියාත්මක වේ. ප්‍රශ්නයේ ඇති අක්ෂර කරන්නේ:

#- ඊළඟ විධානය මඟ හරින්න
>- මෙතැන් සිට, වත්මන් විධානයෙහි දකුණට විධාන කියවනු ලැබේ
v- මෙතැන් සිට, විධාන වත්මන් විධානයට පහළින් කියවනු ලැබේ
5- 5 තොගයට තල්ලු කරන්න -
.අංකය පොප් කර මුද්‍රණය කරන්න තොගයේ ඉහළින්
@- වැඩසටහන අවසන් කරන්න
<space>- කිසිවක් නොකරන්න

ඔබ බෙෆුන්ජ් හි වැඩසටහන් කරන බව ඔබ දැන සිටියා නම්, මෙය කිසිවෙකු රැවටෙන්නේ නැත. නමුත් ඔබ මෙය හමු වී එය බෙෆන්ජ් බව නොදැන සිටියේ නම්, එය බොහෝ දුරට ඉඩ ඇත.

ජාවාස්ක්‍රිප්ට්

කේතය:

var a = 3;
а = 2;
a + а;

ප්‍රතිදානය:

5

ඔබට එය ඔබගේ කොන්සෝලය මත පරීක්ෂා කර බැලීමට හෝ මෙම ෆෙඩලය පරීක්ෂා කළ හැකිය

සී (ලිනක්ස්, ජීසීසී 4.7.3)

#include <stdio.h>

int main(void)
{
    int a=3, b=2;

    printf("%d + %d = %d", --a, b, a+b);  
}

එය 2 + 2 = 5 මුද්‍රණය කරයි

ඉතින් a = 2, හරිද?

gcc-4.7.3 දකුණේ සිට වමට ශ්‍රිත පරාමිතීන් ඇගයීමට ලක් කරයි. A + b තක්සේරු කළ විට, a තවමත් 3 කි.

ෆෝට්‍රාන් 77

       program BadSum
       integer i,a,j
       common i,a
       a = 1
       i = 2
       call addtwo(j) 
       print *,j
       end

       subroutine addtwo(j)
       integer a,i,j
       common a,i
c since a = 1 & i = 2, then 2 + 1 + 1 = 2 + 2 = 4
       j = i + a + a
       end

commonකුට්ටි සම්මත අපයෝජනය : ඇණවුම් කරුණු; මම සබ්ට්‍රවුටින් හි බ්ලොක් එකේ ඇණවුම මාරු කළෙමි 1 + 2 + 2.

පයිතන්

කේත මුද්‍රණ 5 මෙම කාර්යය සඳහා නිවැරදි පිළිතුර වේ.

def int(a):
    return ~eval(a)

def add(a,b):
    return int(a)+int(b)

print ~add("2","2")

සංස්කරණය කරන්න: මෙන්න විකල්ප අනුවාදය වන අතර එය පූර්ණ සංඛ්‍යා එකතු කරයි.

def int(a): return ~eval(`a`)
def add(a,b): return int(a)+int(b)
print ~add(2,2)

ටිල්ඩ් යනු අසමාන ප්‍රතිලෝම ක්‍රියාකරු වන අතර එය නැවත පැමිණේ -x-1, එබැවින් පළමු පියවර ලබා ගැනීම -6සහ පසුව වෙනත් ක්‍රියාකරුවෙකු සමඟ printක්‍රියා කිරීම5

රූබි

class Fixnum
    alias plus +

    def + (other)
        plus(other).succ
    end
end

puts 2 + 2

මෙය සියලු එකතු කිරීම්වල ප්‍රති result ලය වන අතර එහි පළමු තර්කය Fixnum (එය 2, අවම වශයෙන් MRI හි) 1 කින් වැඩි කරයි.

මෙහි අතුරු ආබාධ ජාවා අනුවාදයට වඩා දරුණු ය.

රූබි

රූබිට පළමු පන්තියේ පරිසරයක් ඇත. මෙයින් අදහස් කරන්නේ බොහෝ දේ. එයින් අදහස් කරන්නේ බොහෝ දේ කළ හැකි බවයි ... සමහර විට එසේ නොකළ යුතුය.

def mal(&block)
    block.call
    for v in block.binding.eval("local_variables");
      block.binding.eval('if ' + v.to_s + ' == 4 then ' + v.to_s + ' = 5 end')
    end 
end

a = 2 + 2;
b = 2 + 4;
puts "2 + 2 = ", a
puts "2 + 4 = ", b

mal do
  puts "But in 1984..."
end

puts "2 + 2 = ", a
puts "2 + 4 = ", b

මෙහි ප්‍රතිදානය:

2 + 2 = 
4
2 + 4 = 
6
නමුත් 1984 දී ...
2 + 2 = 
5
2 + 4 = 
6

මෙහි ඇති ප්‍රීතිය හා අන්තරායන් ගැන වැඩි විස්තර දැන ගැනීමට ඔබට අවශ්‍ය නම්, රූබි කොන්ෆ් 2011 රූබි සාධාරණව තබා ගැනීම සහ වියුක්ත මිථ්‍යාදෘෂ්ටික බ්ලොග් අඩවියෙන් පළමු පන්තියේ පරිසරය කියවන්න .

යෝජනා ක්රමය

(define 2+2 5)
2+2 ;=> 5

සී #

var c = Enumerable.Range(2, 2).Sum();

හුරුපුරුදු නැති කෙනෙකුට, මෙය 2 සිට ආරම්භ වන හා අවසන් වන පරාසයක් ලබා ගන්නා බවක් පෙනේ. යථාර්ථයේ දී, එය 2 න් ආරම්භ වී අංක දෙකක් සඳහා යයි. එබැවින් 2 + 3 = 5.

එෆ් #

පහත දැක්වෙන ප්‍රකාශය fsi හි ඇතුළත් කරමු:

let ``2+2``= 5

ප්‍රතිදානය:

val ( 2+2 ) : int = 5

සී

int main() {
        char __func_version__[] = "5";  // For source control
        char b[]="2", a=2;
        printf("%d + %s = %s\n", a, b, a+b);
        return 0;
}

මෙම 5මම බය නෑ, හොඳින් සඟවා නැත. ප්‍රශස්තිකරණය සමඟ ක්‍රියා නොකරයි.