Please help my head is burning from this problem : i have multiple gameobject , same script

Honestly, I couldn't really understand what the problem is, because I wasn't really able to extract any useful information.

Anyways, from what I did understand, you problem seem's to be, that the Transform variable "otherDoor" doesn't change it's value whatsoever, right? Did I understand correctly, that "otherDoor" is the variable, of where the player will be land, after entering the door? Do you set the "otherDoor"-value of each gameObject in the inspector (I am asking, because it's public, and you declared it empty)?

Anyways, maybe this helps: You might want to remove the following line in the "Start"-method: otherDoor = this.GetComponent().otherDoor; because it's redundant. Also, there a few ways to accomplish the changing of the "otherDoor"-variable, for example: -1) You leave it public, so it can be changed/accessed from outside the script, ie from the inspector. -2) In a script, that may function as a sort of scene-manager, you create a List or an Array and an algorithm, which get's each GameObject with Tag or Name "Door", or something like that, and add's an instance of the "NewDoorScript" Type to those GameObjects and the List/Array. Oh, I forgot to mention: You may also want to add a publicly fetchable int-variable, that holds at which index that instance is. Then, you can use the index, to get the position, of the of other door. Let me show you what I mean:

SceneManager.cs:

 using System.Collections.Generic;
 using UnityEngine;
 
 public class SceneManager : MonoBehaviour
 {
     List<NewDoorScript> newDoorList = new List<NewDoorScript>();
 
     static SceneManager smInstance;
 
     public static SceneManager Instance
     { // You may want to extend this to be a singleton pattern.
         get
         {
             return smInstance;
         }
     }
 
     private void Awake()
     {
         // Again, you may want to make this a proper singleton pattern.
         smInstance = this;
 
         AlgorithmOne();
         /*
          * Now, you might want to reverse the list, because
          * the GameObjects are collected form bottom-to-top,
          * viewed from the editor perspective. However, I
          * advise you to put each GameObject tagged "Door"
          * into a parent GameObject, which has no parent
          * (in the scene)
          * Example (the number of dashes represent at which
          * point in the parenting the object is):
          * {
          * Main Camera
          * Directional Light
          * HUD-Canvas
          * Doors
          * -Door 1
          * -Door 2
          * -Door 3
          * -Door 4
          * -Door 5
          * -Door 6
          * Rooms
          * -Room 1
          * --Components
          * -Room 2
          * --Components
          * }
          * And so on.
          * Now, this example implies, that you always need to have
          * an even number of doors, obviously, so no triplets occur,
          * also take a look into my "gbf"-method in NewDoorScript.cs!!
         */
         newDoorList.Reverse();
     }
 
     void AlgorithmOne()
     {
         GameObject[] _doors = GameObject.FindGameObjectsWithTag("Door"); // Get every door
         int _iteration = 0; // Just so we know at which iteration we are
         foreach (GameObject _door in _doors)
         { // Yes, you could use a for-loop, but screw it. :3
             _door.AddComponent<NewDoorScript>(); // Add a script instance
             _door.GetComponent<NewDoorScript>().index = _iteration; // Set the index-value to the current iteration
 
             _iteration++; // Increment the iteration
         }
     }
 
     public NewDoorScript FetchPairedDoor(int _index)
     {
         NewDoorScript _pairedDoor = null;
 
         /*
          * THe following example implies, that
          * i.e. the paired door of Door 1 is Door 2
          * and the paired door of Door 2 is Door 1
          * and the paired door of Door 5 is Door 4
          * Basically, if the given index is even
          * (i.e. divisible by 2 w/o remainder), the
          * paired door is the index +1, otherweise
          * it's the index -1
          * BUT REMEMBER! This system implies you to have
          * an even number of doors in total in the scene!
         */
         if (_index % 2 == 0)
         {
             _pairedDoor = newDoorList[++_index];
         }
         else
         {
             _pairedDoor = newDoorList[--_index];
         }
 
         return _pairedDoor;
     }
 }
 

NewDoorScript.cs: using UnityEngine;

 public class NewDoorScript : MonoBehaviour
 {
     SceneManager sceneManager;
 
     GameObject player;
 
     public int index;
 
     private void Awake()
     {
         sceneManager = SceneManager.Instance;
         player = GameObject.FindGameObjectWithTag("Player");
     }
 
     void gbf()
     {
         GameObject _pairedDoorObject = sceneManager.FetchPairedDoor(index).gameObject;
 
         player.transform.position = new Vector3(_pairedDoorObject.transform.position.x, _pairedDoorObject.transform.position.y, _pairedDoorObject.transform.position.z - 2.0f);
 
         /*
          * Now, you will need to optimize that bit of code, to fit your naming-convention
          * and also you need to implement the offset (_pairedDoorObject.transform.position.z - 2.0f)
          * in a way, that fits your specific level-design. I only took that as a general example, bear
          * that in mind!
         */
     }
 }
 

It should kind of work, haven't really tested it, but again: It's only a barebones construct, so you get an idea, of how that would work! You need to customly implement that!

Hope that helps a bit!